agentxjs 1.9.9-dev → 2.0.0

package/src/presentation/Presentation.ts

@@ -7,12 +7,9 @@
 
 import type { AgentX } from "../types";
 import type { Unsubscribe, BusEvent } from "@agentxjs/core/event";
-import type { PresentationState } from "./types";
-import {
-  presentationReducer,
-  addUserConversation,
-  createInitialState,
-} from "./reducer";
+import type { PresentationState, Conversation } from "./types";
+import { initialPresentationState } from "./types";
+import { presentationReducer, addUserConversation, createInitialState } from "./reducer";
 
 /**
  * Presentation update handler
@@ -50,10 +47,17 @@ export class Presentation {
   private errorHandlers: Set<PresentationErrorHandler> = new Set();
   private eventUnsubscribe: Unsubscribe | null = null;
 
-  constructor(agentx: AgentX, agentId: string, options?: PresentationOptions) {
+  constructor(
+    agentx: AgentX,
+    agentId: string,
+    options?: PresentationOptions,
+    initialConversations?: Conversation[]
+  ) {
     this.agentx = agentx;
     this.agentId = agentId;
-    this.state = createInitialState();
+    this.state = initialConversations?.length
+      ? { ...initialPresentationState, conversations: initialConversations }
+      : createInitialState();
 
     // Register initial handlers
     if (options?.onUpdate) {
@@ -106,7 +110,7 @@ export class Presentation {
 
     try {
       // Send message via agentx
-      await this.agentx.sendMessage(this.agentId, content);
+      await this.agentx.sessions.send(this.agentId, content);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }
@@ -117,7 +121,7 @@ export class Presentation {
    */
   async interrupt(): Promise<void> {
     try {
-      await this.agentx.interrupt(this.agentId);
+      await this.agentx.sessions.interrupt(this.agentId);
     } catch (error) {
       this.notifyError(error instanceof Error ? error : new Error(String(error)));
     }

package/src/presentation/index.ts

@@ -9,6 +9,7 @@ export type {
   TextBlock,
   ToolBlock,
   ImageBlock,
+  TokenUsage,
   Conversation,
   UserConversation,
   AssistantConversation,
@@ -22,6 +23,7 @@ export {
   presentationReducer,
   addUserConversation,
   createInitialState,
+  messagesToConversations,
 } from "./reducer";
 
 export {

package/src/presentation/reducer.ts

@@ -1,22 +1,42 @@
 /**
  * Presentation Reducer
  *
- * Aggregates stream events into PresentationState.
+ * Aggregates events into PresentationState.
  * Pure function: (state, event) => newState
+ *
+ * Event consumption strategy:
+ * - Stream layer: message_start, text_delta, tool_use_start, tool_use_stop, message_stop
+ *   (for real-time streaming display)
+ * - Message layer: tool_result_message
+ *   (for tool execution results — arrives after message_stop)
+ *
+ * Tool calls are stream-level blocks within the assistant turn,
+ * matching the mainstream API pattern (Anthropic, OpenAI).
  */
 
 import type { BusEvent } from "@agentxjs/core/event";
+import type {
+  Message,
+  UserMessage,
+  AssistantMessage,
+  ToolResultMessage,
+  ErrorMessage,
+  ToolResultOutput,
+  ToolCallPart,
+} from "@agentxjs/core/agent";
 import type {
   PresentationState,
+  Conversation,
   AssistantConversation,
   TextBlock,
   ToolBlock,
   Block,
+  TokenUsage,
 } from "./types";
 import { initialPresentationState } from "./types";
 
 // ============================================================================
-// Event Data Types (from stream events)
+// Event Data Types
 // ============================================================================
 
 interface MessageStartData {
@@ -29,18 +49,21 @@ interface TextDeltaData {
 }
 
 interface ToolUseStartData {
-  toolUseId: string;
+  toolCallId: string;
   toolName: string;
 }
 
-interface InputJsonDeltaData {
-  delta: string;
+interface ToolUseStopData {
+  toolCallId: string;
+  toolName: string;
+  input: Record<string, unknown>;
 }
 
-interface ToolResultData {
-  toolUseId: string;
-  result: string;
-  isError?: boolean;
+interface MessageDeltaData {
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
 }
 
 interface MessageStopData {
@@ -57,13 +80,16 @@ interface ErrorData {
 // ============================================================================
 
 /**
- * Reduce a stream event into presentation state
+ * Reduce an event into presentation state.
+ *
+ * Consumes:
+ * - Stream events: message_start, text_delta, tool_use_start, tool_use_stop, message_stop
+ * - Message events: tool_result_message
+ * - Error events: error
  */
-export function presentationReducer(
-  state: PresentationState,
-  event: BusEvent
-): PresentationState {
+export function presentationReducer(state: PresentationState, event: BusEvent): PresentationState {
   switch (event.type) {
+    // Stream layer — real-time display
     case "message_start":
       return handleMessageStart(state, event.data as MessageStartData);
 
@@ -73,15 +99,19 @@ export function presentationReducer(
     case "tool_use_start":
       return handleToolUseStart(state, event.data as ToolUseStartData);
 
-    case "input_json_delta":
-      return handleInputJsonDelta(state, event.data as InputJsonDeltaData);
+    case "tool_use_stop":
+      return handleToolUseStop(state, event.data as ToolUseStopData);
 
-    case "tool_result":
-      return handleToolResult(state, event.data as ToolResultData);
+    case "message_delta":
+      return handleMessageDelta(state, event.data as MessageDeltaData);
 
     case "message_stop":
       return handleMessageStop(state, event.data as MessageStopData);
 
+    // Message layer — tool results from Engine
+    case "tool_result_message":
+      return handleToolResultMessage(state, event.data as ToolResultMessage);
+
     case "error":
       return handleError(state, event.data as ErrorData);
 
@@ -94,11 +124,13 @@ export function presentationReducer(
 // Handlers
 // ============================================================================
 
-function handleMessageStart(
-  state: PresentationState,
-  _data: MessageStartData
-): PresentationState {
-  // Start a new streaming assistant conversation
+function handleMessageStart(state: PresentationState, _data: MessageStartData): PresentationState {
+  // If streaming already exists (e.g. tool_use turn not yet flushed), flush it first
+  let conversations = state.conversations;
+  if (state.streaming && state.streaming.blocks.length > 0) {
+    conversations = [...conversations, { ...state.streaming, isStreaming: false }];
+  }
+
   const streaming: AssistantConversation = {
     role: "assistant",
     blocks: [],
@@ -107,15 +139,13 @@ function handleMessageStart(
 
   return {
     ...state,
+    conversations,
     streaming,
     status: "thinking",
   };
 }
 
-function handleTextDelta(
-  state: PresentationState,
-  data: TextDeltaData
-): PresentationState {
+function handleTextDelta(state: PresentationState, data: TextDeltaData): PresentationState {
   if (!state.streaming) {
     return state;
   }
@@ -123,7 +153,6 @@ function handleTextDelta(
   const blocks = [...state.streaming.blocks];
   const lastBlock = blocks[blocks.length - 1];
 
-  // Append to existing TextBlock or create new one
   if (lastBlock && lastBlock.type === "text") {
     blocks[blocks.length - 1] = {
       ...lastBlock,
@@ -146,17 +175,15 @@ function handleTextDelta(
   };
 }
 
-function handleToolUseStart(
-  state: PresentationState,
-  data: ToolUseStartData
-): PresentationState {
+function handleToolUseStart(state: PresentationState, data: ToolUseStartData): PresentationState {
   if (!state.streaming) {
     return state;
   }
 
+  // Create a pending tool block — toolInput will be filled by tool_use_stop
   const toolBlock: ToolBlock = {
     type: "tool",
-    toolUseId: data.toolUseId,
+    toolUseId: data.toolCallId,
     toolName: data.toolName,
     toolInput: {},
     status: "pending",
@@ -172,64 +199,22 @@ function handleToolUseStart(
   };
 }
 
-function handleInputJsonDelta(
-  state: PresentationState,
-  data: InputJsonDeltaData
-): PresentationState {
-  if (!state.streaming) {
-    return state;
-  }
-
-  const blocks = [...state.streaming.blocks];
-  const lastBlock = blocks[blocks.length - 1];
-
-  // Find the last tool block and update its input
-  if (lastBlock && lastBlock.type === "tool") {
-    // Accumulate JSON delta (will be parsed when complete)
-    const currentInput = (lastBlock as ToolBlock & { _rawInput?: string })._rawInput || "";
-    const newInput = currentInput + data.delta;
-
-    // Try to parse the accumulated JSON
-    let toolInput = lastBlock.toolInput;
-    try {
-      toolInput = JSON.parse(newInput);
-    } catch {
-      // Not yet valid JSON, keep accumulating
-    }
-
-    blocks[blocks.length - 1] = {
-      ...lastBlock,
-      toolInput,
-      _rawInput: newInput,
-      status: "running",
-    } as ToolBlock & { _rawInput?: string };
-
-    return {
-      ...state,
-      streaming: {
-        ...state.streaming,
-        blocks,
-      },
-    };
-  }
-
-  return state;
-}
-
-function handleToolResult(
-  state: PresentationState,
-  data: ToolResultData
-): PresentationState {
+/**
+ * Handle tool_use_stop from stream layer.
+ * Fills in the complete toolInput for the matching pending tool block.
+ * The stream event carries the fully assembled input.
+ */
+function handleToolUseStop(state: PresentationState, data: ToolUseStopData): PresentationState {
   if (!state.streaming) {
     return state;
   }
 
   const blocks = state.streaming.blocks.map((block): Block => {
-    if (block.type === "tool" && block.toolUseId === data.toolUseId) {
+    if (block.type === "tool" && block.toolUseId === data.toolCallId) {
       return {
         ...block,
-        toolResult: data.result,
-        status: data.isError ? "error" : "completed",
+        toolInput: data.input,
+        status: "running",
       };
     }
     return block;
@@ -241,19 +226,43 @@ function handleToolResult(
       ...state.streaming,
       blocks,
     },
-    status: "responding",
   };
 }
 
-function handleMessageStop(
-  state: PresentationState,
-  _data: MessageStopData
-): PresentationState {
+function handleMessageDelta(state: PresentationState, data: MessageDeltaData): PresentationState {
+  if (!state.streaming || !data.usage) {
+    return state;
+  }
+
+  const prev = state.streaming.usage;
+  const usage: TokenUsage = {
+    inputTokens: (prev?.inputTokens ?? 0) + data.usage.inputTokens,
+    outputTokens: (prev?.outputTokens ?? 0) + data.usage.outputTokens,
+  };
+
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      usage,
+    },
+  };
+}
+
+function handleMessageStop(state: PresentationState, data: MessageStopData): PresentationState {
   if (!state.streaming) {
     return state;
   }
 
-  // Move streaming to conversations
+  // tool_use stop → don't flush, tool results are still incoming
+  if (data.stopReason === "tool_use") {
+    return {
+      ...state,
+      status: "executing",
+    };
+  }
+
+  // end_turn / max_tokens / etc → flush streaming to conversations
   const completedConversation: AssistantConversation = {
     ...state.streaming,
     isStreaming: false,
@@ -267,11 +276,49 @@ function handleMessageStop(
   };
 }
 
-function handleError(
+/**
+ * Handle tool_result_message from Engine layer.
+ * Fills in the toolResult for the matching tool block.
+ *
+ * Note: tool_result_message arrives after message_stop(tool_use),
+ * but streaming is kept alive (not flushed) during tool_use turns.
+ */
+function handleToolResultMessage(
   state: PresentationState,
-  data: ErrorData
+  data: ToolResultMessage
 ): PresentationState {
-  // Add error conversation
+  if (!state.streaming) {
+    return state;
+  }
+
+  const toolCallId = data.toolCallId;
+  const blocks = state.streaming.blocks.map((block): Block => {
+    if (block.type === "tool" && block.toolUseId === toolCallId) {
+      return {
+        ...block,
+        toolResult: formatToolResultOutput(data.toolResult.output),
+        status:
+          data.toolResult.output.type === "error-text" ||
+          data.toolResult.output.type === "error-json" ||
+          data.toolResult.output.type === "execution-denied"
+            ? "error"
+            : "completed",
+      };
+    }
+    return block;
+  });
+
+  return {
+    ...state,
+    streaming: {
+      ...state.streaming,
+      blocks,
+    },
+    status: "responding",
+  };
+}
+
+function handleError(state: PresentationState, data: ErrorData): PresentationState {
   return {
     ...state,
     conversations: [
@@ -290,13 +337,7 @@ function handleError(
 // Helper: Add user conversation
 // ============================================================================
 
-/**
- * Add a user conversation to state
- */
-export function addUserConversation(
-  state: PresentationState,
-  content: string
-): PresentationState {
+export function addUserConversation(state: PresentationState, content: string): PresentationState {
   return {
     ...state,
     conversations: [
@@ -309,9 +350,137 @@ export function addUserConversation(
   };
 }
 
-/**
- * Create initial state
- */
 export function createInitialState(): PresentationState {
   return { ...initialPresentationState };
 }
+
+// ============================================================================
+// Helper: Format tool result output
+// ============================================================================
+
+function formatToolResultOutput(output: ToolResultOutput): string {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "execution-denied":
+      return output.reason ?? "Execution denied";
+    case "content":
+      return output.value
+        .filter((p): p is { type: "text"; text: string } => p.type === "text")
+        .map((p) => p.text)
+        .join("");
+  }
+}
+
+// ============================================================================
+// Message → Conversation Converter
+// ============================================================================
+
+/**
+ * Convert persisted Messages to Presentation Conversations.
+ *
+ * Groups consecutive assistant + tool-result messages
+ * into a single AssistantConversation.
+ *
+ * Tool calls are now part of AssistantMessage.content (as ToolCallPart),
+ * so we extract them directly from the assistant message.
+ */
+export function messagesToConversations(messages: Message[]): Conversation[] {
+  const conversations: Conversation[] = [];
+  let currentAssistant: AssistantConversation | null = null;
+
+  function flushAssistant() {
+    if (currentAssistant && currentAssistant.blocks.length > 0) {
+      conversations.push(currentAssistant);
+    }
+    currentAssistant = null;
+  }
+
+  for (const msg of messages) {
+    switch (msg.subtype) {
+      case "user": {
+        flushAssistant();
+        const m = msg as UserMessage;
+        const text =
+          typeof m.content === "string"
+            ? m.content
+            : m.content
+                .filter((p): p is { type: "text"; text: string } => p.type === "text")
+                .map((p) => p.text)
+                .join("");
+        conversations.push({
+          role: "user",
+          blocks: [{ type: "text", content: text }],
+        });
+        break;
+      }
+
+      case "assistant": {
+        if (!currentAssistant) {
+          currentAssistant = { role: "assistant", blocks: [], isStreaming: false };
+        }
+        const m = msg as AssistantMessage;
+        if (typeof m.content === "string") {
+          if (m.content) {
+            currentAssistant.blocks.push({ type: "text", content: m.content } as TextBlock);
+          }
+        } else {
+          // Extract text and tool call parts from content
+          for (const part of m.content) {
+            if (part.type === "text") {
+              if (part.text) {
+                currentAssistant.blocks.push({ type: "text", content: part.text } as TextBlock);
+              }
+            } else if (part.type === "tool-call") {
+              const tc = part as ToolCallPart;
+              currentAssistant.blocks.push({
+                type: "tool",
+                toolUseId: tc.id,
+                toolName: tc.name,
+                toolInput: tc.input,
+                status: "completed",
+              } as ToolBlock);
+            }
+          }
+        }
+        break;
+      }
+
+      case "tool-result": {
+        const m = msg as ToolResultMessage;
+        if (currentAssistant) {
+          for (const block of currentAssistant.blocks) {
+            if (block.type === "tool" && block.toolUseId === m.toolResult.id) {
+              block.toolResult = formatToolResultOutput(m.toolResult.output);
+              block.status =
+                m.toolResult.output.type === "error-text" ||
+                m.toolResult.output.type === "error-json" ||
+                m.toolResult.output.type === "execution-denied"
+                  ? "error"
+                  : "completed";
+              break;
+            }
+          }
+        }
+        break;
+      }
+
+      case "error": {
+        flushAssistant();
+        const m = msg as ErrorMessage;
+        conversations.push({
+          role: "error",
+          message: m.content,
+        });
+        break;
+      }
+    }
+  }
+
+  flushAssistant();
+  return conversations;
+}

package/src/presentation/types.ts

@@ -55,6 +55,14 @@ export interface UserConversation {
   blocks: Block[];
 }
 
+/**
+ * Token usage for a message (one LLM call / step)
+ */
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+}
+
 /**
  * Assistant conversation
  */
@@ -62,6 +70,8 @@ export interface AssistantConversation {
   role: "assistant";
   blocks: Block[];
   isStreaming: boolean;
+  /** Accumulated token usage across all steps in this conversation */
+  usage?: TokenUsage;
 }
 
 /**