Pi Framework 엔진 해부: OpenClaw를 움직이는 ReAct 이중 루프의 비밀

type AgentEvent =
  | { type: "agent_start" }
  | { type: "agent_end"; messages: AgentMessage[] }
  | { type: "turn_start" }
  | { type: "turn_end"; message: AgentMessage; toolResults: ToolResultMessage[] }
  | { type: "message_start"; message: AgentMessage }
  | { type: "message_update"; message: AgentMessage; assistantMessageEvent }
  | { type: "message_end"; message: AgentMessage }
  | { type: "tool_execution_start"; toolCallId, toolName, args }
  | { type: "tool_execution_update"; partialResult }
  | { type: "tool_execution_end"; result, isError }

interface ApiProvider<TApi extends string, TOptions> {
  api: TApi;
  stream: StreamFunction<TOptions>;
  streamSimple?: SimpleStreamFunction;
}
 
class ApiRegistry {
  private providers = new Map<string, ApiProvider<any, any>>();
 
  register<TApi, TOptions>(provider: ApiProvider<TApi, TOptions>): void;
  get<TApi>(api: TApi): ApiProvider<TApi, any> | undefined;
  list(): string[];
}

interface Model<TApi extends Api = Api> {
  id: string;                    // Model identifier
  name: string;                  // Human-readable name
  api: TApi;                     // API to use
  provider: KnownProvider;       // Provider name
  baseUrl?: string;              // Custom base URL
  reasoning: boolean;            // Supports thinking/reasoning
  input: ("text" | "image")[];   // Input modalities
  cost: {                        // Pricing (per 1M tokens)
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
  };
  contextWindow: number;         // Max context tokens
  maxTokens: number;             // Max output tokens
  headers?: Record<string, string>;
  compat?: CompatSettings;       // Provider-specific quirks
}

type AssistantMessageEvent =
  | { type: "start"; partial: AssistantMessage }
  | { type: "text_start"; contentIndex: number }
  | { type: "text_delta"; delta: string; contentIndex: number; partial: AssistantMessage }
  | { type: "text_end"; content: TextContent; contentIndex: number }
  | { type: "thinking_start"; contentIndex: number }
  | { type: "thinking_delta"; delta: string; contentIndex: number; partial: AssistantMessage }
  | { type: "thinking_end"; content: ThinkingContent; contentIndex: number }
  | { type: "toolcall_start"; contentIndex: number }
  | { type: "toolcall_delta"; delta: string; contentIndex: number; partial: AssistantMessage }
  | { type: "toolcall_end"; toolCall: ToolCall; contentIndex: number }
  | { type: "done"; reason: StopReason; message: AssistantMessage }
  | { type: "error"; reason: "error" | "aborted"; error: AssistantMessage };

export class Agent {
  private _state: AgentState;
  private listeners: Set<(e: AgentEvent) => void>;
  private steeringQueue: AgentMessage[];
  private followUpQueue: AgentMessage[];
  private abortController?: AbortController;
 
  // State accessors
  get state(): AgentState;
  setSystemPrompt(v: string): void;
  setModel(m: Model<any>): void;
  setThinkingLevel(l: ThinkingLevel): void;
  setTools(t: AgentTool<any>[]): void;
 
  // Queue management
  steer(m: AgentMessage): void;          // Interrupt
  followUp(m: AgentMessage): void;        // After completion
 
  // Control
  async prompt(input: string | AgentMessage, images?: ImageContent[]): Promise<void>;
  async continue(): Promise<void>;
  abort(): void;
 
  // Events
  subscribe(fn: (e: AgentEvent) => void): () => void;
}

export class AgentSession {
  private agent: Agent;
  private sessionManager: SessionManager;
  private extensionRunner: ExtensionRunner;
  private modelRegistry: ModelRegistry;
  private resourceLoader: ResourceLoader;
 
  async prompt(input: string, options?: PromptOptions): Promise<void>;
  async switchSession(sessionId: string): Promise<void>;
  async createBranch(entryId: string): Promise<void>;
  async compact(customInstructions?: string): Promise<CompactionResult>;
  async setModel(model: Model<any>, thinkingLevel?: ThinkingLevel): Promise<void>;
  cycleModel(direction: "forward" | "backward"): ModelCycleResult;
  subscribe(listener: AgentSessionEventListener): () => void;
}

// Box: Container component
interface Box {
  x: number; y: number;
  width: number; height: number;
  style?: Style;
  content?: string;
  children?: Box[];
}
 
class Renderer {
  render(root: Box): void;
  clear(): void;
  resize(width: number, height: number): void;
}

async function runLoop(
  currentContext: AgentContext,
  newMessages: AgentMessage[],
  config: AgentLoopConfig,
  signal: AbortSignal | undefined,
  stream: EventStream<AgentEvent, AgentMessage[]>,
  streamFn?: StreamFn
): Promise<void> {
  let firstTurn = true;
  let pendingMessages: AgentMessage[] = await config.getSteeringMessages?.() || [];
 
  // ==================== OUTER LOOP ====================
  while (true) {
    let hasMoreToolCalls = true;
    let steeringAfterTools: AgentMessage[] | null = null;
 
    // ==================== INNER LOOP ====================
    while (hasMoreToolCalls || pendingMessages.length > 0) {
      // [Inner loop implementation]
    }
 
    // ==================== FOLLOW-UP CHECK ====================
    const followUpMessages = await config.getFollowUpMessages?.() || [];
    if (followUpMessages.length > 0) {
      pendingMessages = followUpMessages;
      continue; // Restart inner loop
    }
 
    break; // No more work, exit outer loop
  }
 
  stream.push({ type: "agent_end", messages: newMessages });
  stream.end(newMessages);
}

// ==================== INNER LOOP ====================
while (hasMoreToolCalls || pendingMessages.length > 0) {
  if (!firstTurn) {
    stream.push({ type: "turn_start" });
  } else {
    firstTurn = false;
  }
 
  // ==================== STEP 1: INJECT PENDING MESSAGES ====================
  if (pendingMessages.length > 0) {
    for (const message of pendingMessages) {
      stream.push({ type: "message_start", message });
      stream.push({ type: "message_end", message });
      currentContext.messages.push(message);
      newMessages.push(message);
    }
    pendingMessages = [];
  }
 
  // ==================== STEP 2: STREAM LLM RESPONSE ====================
  const message = await streamAssistantResponse(
    currentContext, config, signal, stream, streamFn
  );
  newMessages.push(message);
 
  // ==================== STEP 3: ERROR HANDLING ====================
  if (message.stopReason === "error" || message.stopReason === "aborted") {
    stream.push({ type: "turn_end", message, toolResults: [] });
    stream.push({ type: "agent_end", messages: newMessages });
    stream.end(newMessages);
    return; // Exit immediately
  }
 
  // ==================== STEP 4: TOOL EXECUTION ====================
  const toolCalls = message.content.filter(c => c.type === "toolCall");
  hasMoreToolCalls = toolCalls.length > 0;
 
  const toolResults: ToolResultMessage[] = [];
  if (hasMoreToolCalls) {
    const toolExecution = await executeToolCalls(
      currentContext.tools, message, signal, stream,
      config.getSteeringMessages
    );
    toolResults.push(...toolExecution.toolResults);
    steeringAfterTools = toolExecution.steeringMessages ?? null;
 
    for (const result of toolResults) {
      currentContext.messages.push(result);
      newMessages.push(result);
    }
  }
 
  stream.push({ type: "turn_end", message, toolResults });
 
  // ==================== STEP 5: STEERING CHECK ====================
  if (steeringAfterTools && steeringAfterTools.length > 0) {
    pendingMessages = steeringAfterTools;
    steeringAfterTools = null;
  } else {
    pendingMessages = await config.getSteeringMessages?.() || [];
  }
}

async function streamAssistantResponse(
  context: AgentContext,
  config: AgentLoopConfig,
  signal: AbortSignal | undefined,
  stream: EventStream<AgentEvent, AgentMessage[]>,
  streamFn?: StreamFn
): Promise<AssistantMessage> {
  // STEP 1: TRANSFORM CONTEXT (Optional)
  let messages = context.messages;
  if (config.transformContext) {
    messages = await config.transformContext(messages, signal);
  }
 
  // STEP 2: CONVERT TO LLM FORMAT
  const llmMessages = await config.convertToLlm(messages);
 
  // STEP 3: BUILD LLM CONTEXT
  const llmContext: Context = {
    systemPrompt: context.systemPrompt,
    messages: llmMessages,
    tools: context.tools,
  };
 
  // STEP 4: RESOLVE API KEY
  const resolvedApiKey =
    (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined)
    || config.apiKey;
 
  // STEP 5: STREAM FROM LLM
  const streamFunction = streamFn || streamSimple;
  const response = await streamFunction(config.model, llmContext, {
    ...config,
    apiKey: resolvedApiKey,
    signal,
  });
 
  // STEP 6: PROCESS EVENTS
  for await (const event of response) {
    switch (event.type) {
      case "start":
        // Initialize partial message
        break;
      case "text_delta":
      case "thinking_delta":
      case "toolcall_delta":
        // Update partial message, emit message_update
        break;
      case "done":
      case "error":
        // Finalize message, emit message_end
        return finalMessage;
    }
  }
}

async function executeToolCalls(
  tools: AgentTool<any>[] | undefined,
  assistantMessage: AssistantMessage,
  signal: AbortSignal | undefined,
  stream: EventStream<AgentEvent, AgentMessage[]>,
  getSteeringMessages?: () => Promise<AgentMessage[]>
): Promise<{ toolResults: ToolResultMessage[]; steeringMessages?: AgentMessage[] }> {
  const toolCalls = assistantMessage.content.filter(c => c.type === "toolCall");
  const results: ToolResultMessage[] = [];
  let steeringMessages: AgentMessage[] | undefined;
 
  for (let i = 0; i < toolCalls.length; i++) {
    const toolCall = toolCalls[i];
    const tool = tools?.find(t => t.name === toolCall.name);
 
    stream.push({
      type: "tool_execution_start",
      toolCallId: toolCall.id,
      toolName: toolCall.name,
      args: toolCall.arguments,
    });
 
    let result: AgentToolResult<any>;
    let isError = false;
 
    try {
      if (!tool) throw new Error(`Tool ${toolCall.name} not found`);
      const validatedArgs = validateToolArguments(tool, toolCall);
 
      result = await tool.execute(
        toolCall.id,
        validatedArgs,
        signal,
        (partialResult) => {
          stream.push({
            type: "tool_execution_update",
            toolCallId: toolCall.id,
            toolName: toolCall.name,
            args: toolCall.arguments,
            partialResult,
          });
        }
      );
    } catch (e) {
      result = {
        content: [{ type: "text", text: e instanceof Error ? e.message : String(e) }],
        details: {},
      };
      isError = true;
    }
 
    // Create ToolResultMessage and check for steering
    // ...
 
    if (getSteeringMessages) {
      const steering = await getSteeringMessages();
      if (steering.length > 0) {
        steeringMessages = steering;
        // Skip remaining tools
        const remaining = toolCalls.slice(i + 1);
        for (const skipped of remaining) {
          results.push(skipToolCall(skipped, stream));
        }
        break;
      }
    }
  }
 
  return { toolResults: results, steeringMessages };
}

type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";

// OpenAI (reasoning effort)
if (model.provider === "openai") {
  options.reasoningEffort = thinkingLevel; // "low" | "medium" | "high"
}
 
// Anthropic (thinking enabled + token budget)
if (model.provider === "anthropic") {
  options.thinkingEnabled = thinkingLevel !== "off";
  options.thinkingBudgetTokens = thinkingBudgets[thinkingLevel]; // 128, 512, 1024, 2048
}
 
// Google (thinking config)
if (model.provider === "google") {
  options.thinking = {
    enabled: thinkingLevel !== "off",
    budgetTokens: thinkingBudgets[thinkingLevel],
  };
}

export interface AgentState {
  // Configuration
  systemPrompt: string;
  model: Model<any>;
  thinkingLevel: ThinkingLevel; // "off" | "minimal" | "low" | "medium" | "high" | "xhigh"
  tools: AgentTool<any>[];
 
  // Conversation
  messages: AgentMessage[]; // Full history
 
  // Runtime status
  isStreaming: boolean;
  streamMessage: AgentMessage | null;
  pendingToolCalls: Set<string>;
  error?: string;
}

export default function subAgentExtension(api: ExtensionAPI) {
  api.registerTool({
    name: "spawn_sub_agent",
    label: "Spawn Sub-Agent",
    description: "Create a sub-agent for parallel task execution",
    parameters: Type.Object({
      task: Type.String({ description: "Task for sub-agent" }),
      model: Type.Optional(Type.String({ description: "Model override" })),
    }),
    execute: async (id, params, signal, onUpdate) => {
      const subAgent = new Agent({
        initialState: {
          systemPrompt: `You are a sub-agent. Task: ${params.task}`,
          model: params.model ? getModel(...) : api.getAgent().state.model,
          tools: api.getAgent().state.tools,
        },
      });
 
      const result = await new Promise<string>((resolve) => {
        subAgent.subscribe((event) => {
          if (event.type === "agent_end") {
            const lastMessage = event.messages[event.messages.length - 1];
            resolve(extractText(lastMessage));
          }
        });
        subAgent.prompt(params.task);
      });
 
      return {
        content: [{ type: "text", text: result }],
        details: { task: params.task },
      };
    },
  });
}

export default function approvalExtension(api: ExtensionAPI) {
  api.wrapTool("bash", (originalTool) => {
    return {
      ...originalTool,
      execute: async (id, params, signal, onUpdate) => {
        const command = params.command;
        const dangerous = /rm|del|format|shutdown/.test(command);
 
        if (dangerous) {
          const confirmed = await api.showConfirmation(
            `Execute dangerous command?\n${command}`
          );
          if (!confirmed) {
            throw new Error("User cancelled operation");
          }
        }
 
        return await originalTool.execute(id, params, signal, onUpdate);
      },
    };
  });
}

// Provider Strategy Interface
interface ProviderStream {
  (model: Model, context: Context, options: StreamOptions):
    AsyncGenerator<AssistantMessageEvent>
}
 
// Concrete Strategies
const providers: Record<Api, ProviderStream> = {
  "openai-completions": streamOpenAICompletions,
  "anthropic-messages": streamAnthropic,
  "google-generative-ai": streamGoogle,
  // ... 15+ more providers
};
 
// Unified interface
async function* streamSimple(
  model: Model,
  context: Context,
  options?: SimpleStreamOptions
): AssistantMessageEventStream {
  const provider = providers[model.api];
  yield* provider(model, context, options);
}

export async function* streamSimple(
  model: Model<any>,
  context: Context,
  options?: SimpleStreamOptions
): AssistantMessageEventStream {
  // 1. Select provider
  const api = apiRegistry.get(model.api);
 
  // 2. Resolve API key
  const apiKey = options?.apiKey || getEnvApiKey(model.provider);
 
  // 3. Map options to provider format
  const providerOptions = mapOptionsForApi(model.api, options);
 
  // 4. Stream from provider
  yield* api.stream(model, context, providerOptions);
}

export async function* streamAnthropic(
  model: Model<"anthropic-messages">,
  context: Context,
  options: AnthropicOptions
): AssistantMessageEventStream {
  // 1. Transform messages to Anthropic format
  const anthropicMessages = transformMessages(context.messages);
 
  // 2. Build request payload
  const payload = {
    model: model.id,
    messages: anthropicMessages,
    system: context.systemPrompt,
    tools: context.tools?.map(transformTool),
    thinking: options.thinkingEnabled ? { type: "enabled" } : undefined,
    max_tokens: model.maxTokens,
    stream: true,
  };
 
  // 3. Send request
  const response = await fetch(`${model.baseUrl}/v1/messages`, {
    method: "POST",
    headers: {
      "x-api-key": options.apiKey,
      "anthropic-version": "2023-06-01",
      "content-type": "application/json",
    },
    body: JSON.stringify(payload),
  });
 
  // 4. Parse streaming response
  for await (const event of parseSSE(response.body)) {
    switch (event.type) {
      case "content_block_delta":
        if (event.delta.type === "text_delta") {
          yield { type: "text_delta", delta: event.delta.text, ... };
        }
        break;
      case "message_stop":
        yield { type: "done", reason: "stop", message: ... };
        break;
    }
  }
}

function transformMessages(
  messages: Message[],
  targetApi: Api,
  sourceApi?: Api
): ProviderMessage[] {
  return messages.map(msg => {
    // User messages: pass through
    if (msg.role === "user") {
      return transformUserMessage(msg, targetApi);
    }
 
    // Assistant messages from same provider/API: preserve
    if (msg.role === "assistant" && msg.api === targetApi) {
      return msg;
    }
 
    // Assistant messages from different providers:
    // Convert thinking blocks to <thinking> tagged text
    if (msg.role === "assistant") {
      return transformCrossProviderAssistant(msg, targetApi);
    }
 
    // Tool results: pass through
    if (msg.role === "toolResult") {
      return transformToolResult(msg, targetApi);
    }
  });
}

declare module "@mariozechner/pi-agent-core" {
  interface CustomAgentMessages {
    notification: { role: "notification"; text: string; timestamp: number };
    artifact: { role: "artifact"; artifactId: string; content: string; timestamp: number };
  }
}

interface Tool<TParameters extends TSchema = TSchema> {
  name: string;
  description: string;
  parameters: TParameters; // TypeBox schema
}
 
interface ToolCall {
  id: string;
  name: string;
  arguments: Record<string, any>;
}
 
interface ToolResultMessage {
  role: "toolResult";
  toolCallId: string;
  toolName: string;
  content: (TextContent | ImageContent)[];
  isError: boolean;
  timestamp: number;
}

function validateToolCall(tools: Tool[], toolCall: ToolCall): any {
  const tool = tools.find(t => t.name === toolCall.name);
  if (!tool) throw new Error(`Tool ${toolCall.name} not found`);
 
  const validator = ajv.compile(tool.parameters);
  if (!validator(toolCall.arguments)) {
    throw new Error(`Invalid arguments: ${ajv.errorsText(validator.errors)}`);
  }
 
  return toolCall.arguments;
}

interface ExtensionAPI {
  // ========== Event Subscription ==========
  on<T extends ExtensionEventType>(
    event: T,
    handler: ExtensionEventHandler<T>
  ): void;
 
  // ========== Tool Registration ==========
  registerTool<TParams extends TSchema = TSchema, TDetails = unknown>(
    definition: ToolDefinition<TParams, TDetails>
  ): void;
  getAllTools(): ToolInfo[];
  getActiveTools(): string[];
  setActiveTools(names: string[]): void;
 
  // ========== Command Registration ==========
  registerCommand(
    name: string,
    options: {
      description: string;
      handler: (args: string, ctx: ExtensionCommandContext) => Promise<void>;
      getArgumentCompletions?: (prefix: string) => AutocompleteItem[] | null;
    }
  ): void;
 
  // ========== Shortcut Registration ==========
  registerShortcut(
    shortcut: string,
    options: {
      description: string;
      handler: (ctx: ExtensionContext) => Promise<void>;
    }
  ): void;
 
  // ========== Message Injection ==========
  sendMessage(
    message: {
      customType: string;
      content: string | (TextContent | ImageContent)[];
      display: boolean;
      details?: any;
    },
    options?: {
      triggerTurn?: boolean;
      deliverAs?: "steer" | "followUp" | "nextTurn";
    }
  ): Promise<void>;
 
  sendUserMessage(
    content: string | (TextContent | ImageContent)[],
    options?: {
      deliverAs?: "steer" | "followUp";
    }
  ): Promise<void>;
 
  // ========== State Persistence ==========
  appendEntry(customType: string, data?: any): void;
  setSessionName(name: string): void;
  setLabel(entryId: string, label: string | undefined): void;
 
  // ========== Rendering ==========
  registerMessageRenderer(
    customType: string,
    renderer: (message: CustomMessage, options, theme: Theme) => Component | undefined
  ): void;
 
  // ========== Model Management ==========
  setModel(model: Model): Promise<boolean>;
  getThinkingLevel(): ThinkingLevel;
  setThinkingLevel(level: ThinkingLevel): void;
 
  // ========== Provider Registration ==========
  registerProvider(name: string, config: ProviderConfig): void;
  unregisterProvider(name: string): void;
 
  // ========== Utility ==========
  exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
  readonly events: EventBus;
}

type ExtensionEvent =
  // Session Events
  | SessionStartEvent
  | SessionBeforeSwitchEvent
  | SessionSwitchEvent
  | SessionBeforeCompactEvent
  | SessionCompactEvent
  | SessionShutdownEvent
  | SessionBeforeTreeEvent
  | SessionTreeEvent
 
  // Agent Events
  | BeforeAgentStartEvent
  | AgentStartEvent
  | AgentEndEvent
  | TurnStartEvent
  | TurnEndEvent
  | MessageStartEvent
  | MessageUpdateEvent
  | MessageEndEvent
  | ToolExecutionStartEvent
  | ToolExecutionUpdateEvent
  | ToolExecutionEndEvent
  | ContextEvent
 
  // Tool Events
  | ToolCallEvent
  | ToolResultEvent
 
  // User Events
  | UserBashEvent
  | InputEvent
 
  // Model Events
  | ModelSelectEvent
 
  // Resource Events
  | ResourcesDiscoverEvent;

pi.on("before_agent_start", async (event, ctx) => {
  return {
    message: {
      customType: "my-ext:context",
      content: "Additional context for this turn",
      display: false
    },
    systemPrompt: event.systemPrompt + "\n\nExtra instructions..."
  };
});

pi.on("tool_call", async (event, ctx) => {
  if (event.toolName === "bash") {
    const command = event.input.command;
    if (command.includes("rm -rf")) {
      const ok = await ctx.ui.confirm("Dangerous Command", `Allow: ${command}?`);
      if (!ok) {
        return { block: true, reason: "Blocked by user" };
      }
    }
  }
});

pi.on("context", async (event, ctx) => {
  const filtered = event.messages.filter(msg => {
    if (msg.role === "user" && msg.timestamp) {
      const age = Date.now() - msg.timestamp;
      return age < 3600000; // 1시간 이내
    }
    return true;
  });
  return { messages: filtered };
});

pi.registerTool({
  name: "calculator",
  label: "Calculator",
  description: "Perform basic arithmetic operations",
  parameters: Type.Object({
    operation: StringEnum(["add", "subtract", "multiply", "divide"] as const),
    a: Type.Number({ description: "First operand" }),
    b: Type.Number({ description: "Second operand" }),
  }),
  async execute(toolCallId, params, signal, onUpdate, ctx) {
    // implementation
    return {
      content: [{ type: "text", text: `${params.a} ${params.operation} ${params.b} = ${result}` }],
      details: { result }
    };
  }
});

export default function planningExtension(api: ExtensionAPI) {
  api.registerCommand("plan", {
    description: "Create a plan for the given task",
    handler: async (args, ctx) => {
      const task = args.join(" ");
 
      const planningAgent = new Agent({
        initialState: {
          systemPrompt: `You are a planning agent. Break down tasks into steps.
Output format:
1. Step 1
2. Step 2
...`,
          model: api.getAgent().state.model,
          tools: [],
        },
      });
 
      let plan = "";
      planningAgent.subscribe((event) => {
        if (event.type === "message_update" &&
            event.assistantMessageEvent.type === "text_delta") {
          plan += event.assistantMessageEvent.delta;
        }
      });
 
      await planningAgent.prompt(`Create a plan for: ${task}`);
      await fs.writeFile(".pi/plan.md", plan);
      ctx.notify(`Plan created in .pi/plan.md`);
    },
  });
}

{"id":"1","parentId":null,"role":"user","content":"Hello","timestamp":1709712000000}
{"id":"2","parentId":"1","role":"assistant","content":"Hi!","timestamp":1709712001000}
{"id":"3","parentId":"2","role":"user","content":"Help","timestamp":1709712010000}
{"id":"4","parentId":"3","role":"assistant","content":"Sure!","timestamp":1709712011000}

export async function compact(
  agent: Agent,
  context: AgentContext,
  config: CompactionConfig
): Promise<CompactionResult> {
  // 1. Prepare compaction
  const prep = await prepareCompaction(context, config);
  if (!prep.shouldCompact) return { compacted: false };
 
  // 2. Build compaction prompt
  const compactionContext: Context = {
    systemPrompt: buildCompactionSystemPrompt(config.instructions),
    messages: [{
      role: "user",
      content: buildCompactionPrompt(prep.messagesToCompact),
      timestamp: Date.now(),
    }],
  };
 
  // 3. Call LLM for summary
  const summary = await complete(config.model, compactionContext);
  const summaryText = extractText(summary);
 
  // 4. Replace old messages with summary
  const compactedMessages: AgentMessage[] = [
    {
      role: "user",
      content: `<compaction>\n${summaryText}\n</compaction>`,
      timestamp: Date.now(),
    },
    ...prep.messagesToKeep,
  ];
 
  // 5. Update agent context
  agent.replaceMessages(compactedMessages);
 
  return {
    compacted: true,
    summary: summaryText,
    removedMessages: prep.messagesToCompact.length,
    keptMessages: prep.messagesToKeep.length,
  };
}