agent-api-server 2.1.10__tar.gz → 2.1.12__tar.gz

{agent_api_server-2.1.10 → agent_api_server-2.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agent-api-server
-Version: 2.1.10
+Version: 2.1.12
 Summary: A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot
 Author: zijie.zhang@advantech.com.cn
 Requires-Python: >=3.10,<3.13

{agent_api_server-2.1.10 → agent_api_server-2.1.12}/agent_api_server/acp_bridge/go/agent.go

@@ -39,6 +39,12 @@ type SessionState struct {
 	UpdatedAt string `json:"updated_at,omitempty"`
 }
 
+// pendingToolCall holds buffered tool call info until the tool result is available.
+type pendingToolCall struct {
+	name string
+	args interface{}
+}
+
 // AgentHubACPAgent implements the ACP protocol over stdio, proxying to an HTTP backend.
 type AgentHubACPAgent struct {
 	serviceURL     string
@@ -54,7 +60,7 @@ type AgentHubACPAgent struct {
 	mu               sync.Mutex
 	httpClient       *http.Client
 	sessions         map[string]*SessionState
-	pendingToolCalls map[string]map[string]string // sessionID -> tcID -> tcName
+	pendingToolCalls map[string]map[string]*pendingToolCall // sessionID -> tcID -> info
 	streamedNodes    map[string]map[string]bool   // sessionID -> set of nodes
 }
 
@@ -77,7 +83,7 @@ func NewAgentHubACPAgent(
 		extraInputs:      extraInputs,
 		streamMode:     streamMode,
 		sessions:         make(map[string]*SessionState),
-		pendingToolCalls: make(map[string]map[string]string),
+		pendingToolCalls: make(map[string]map[string]*pendingToolCall),
 		streamedNodes:    make(map[string]map[string]bool),
 		httpClient: &http.Client{
 			Timeout: 300 * time.Second,
@@ -348,24 +354,22 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 			a.mu.Lock()
 			pending := a.pendingToolCalls[sessionID]
 			if pending == nil {
-				pending = make(map[string]string)
+				pending = make(map[string]*pendingToolCall)
 				a.pendingToolCalls[sessionID] = pending
 			}
 			a.mu.Unlock()
 			for _, tc := range toolCalls {
-				tcID, _ := tc["id"].(string)
-				if tcID == "" {
-					tcID = uuid.New().String()
-				}
+				// Always use UUID for tcID to avoid invalid IDs from LangChain
+				tcID := uuid.New().String()
 				tcName, _ := tc["name"].(string)
 				if tcName == "" {
 					tcName = "unknown"
 				}
 				tcArgs := tc["args"]
+				// Buffer tool call info; emit complete tool_call when tools_message arrives
 				a.mu.Lock()
-				pending[tcID] = tcName
+				pending[tcID] = &pendingToolCall{name: tcName, args: tcArgs}
 				a.mu.Unlock()
-				a.sendStartToolCall(sessionID, tcID, tcName, tcArgs, nil, "")
 			}
 		} else if text != "" {
 			a.mu.Lock()
@@ -390,12 +394,13 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 		a.mu.Unlock()
 
 		if len(pending) > 0 {
-			for tcID, tcName := range pending {
+			for tcID, info := range pending {
 				output := text
 				if output == "" {
-					output = tcName + " completed"
+					output = info.name + " completed"
 				}
-				a.sendUpdateToolCall(sessionID, tcID, "completed", output)
+				// Emit single complete tool_call with rawInput + rawOutput
+				a.sendStartToolCall(sessionID, tcID, info.name, info.args, output, "completed")
 			}
 			a.mu.Lock()
 			delete(a.pendingToolCalls, sessionID)
@@ -412,10 +417,8 @@ func (a *AgentHubACPAgent) processSSEEvent(sessionID, raw string) {
 				}
 			}
 			for _, tc := range toolCalls {
-				tcID, _ := tc["id"].(string)
-				if tcID == "" {
-					tcID = uuid.New().String()
-				}
+				// Always use UUID for tcID to avoid invalid IDs from LangChain
+				tcID := uuid.New().String()
 				tcName, _ := tc["name"].(string)
 				if tcName == "" {
 					tcName = "unknown"

{agent_api_server-2.1.10 → agent_api_server-2.1.12}/agent_api_server/acp_bridge/go/main.go

@@ -301,7 +301,6 @@ func (a *AgentHubACPAgent) handleLoadSession(req jsonrpcRequest) *jsonrpcRespons
 func (a *AgentHubACPAgent) loadSessionHistory(sessionID, cwd string) {
 	params := url.Values{
 		"user_input_field":     {a.userInputField},
-		"include_node_history": {"true"},
 	}
 	resp, err := a.doRequest("GET", "/api/v1/thread/"+sessionID+"/history", nil, params)
 	if err != nil {
@@ -317,129 +316,48 @@ func (a *AgentHubACPAgent) loadSessionHistory(sessionID, cwd string) {
 
 	var data struct {
 		Messages       []map[string]interface{} `json:"messages"`
-		NodeExecutions []map[string]interface{} `json:"node_executions"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&data); err != nil {
 		log.Printf("Failed to decode session history: %v", err)
 		return
 	}
 
-	if len(data.NodeExecutions) > 0 {
-		a.replayNodeExecutions(sessionID, data.NodeExecutions)
-	} else {
-		a.replayMessages(sessionID, data.Messages)
-	}
+	a.replayMessages(sessionID, data.Messages)
 
 	log.Printf("Loaded session %s with %d messages", sessionID, len(data.Messages))
 }
 
-// replayNodeExecutions replays session history using node_executions data.
-// Each nodeExecution represents one turn (user question + AI response).
-// We process messages in order within each turn to maintain proper conversation flow.
-func (a *AgentHubACPAgent) replayNodeExecutions(sessionID string, nodeExecutions []map[string]interface{}) {
-	shownContents := make(map[string]bool)
-
-	for _, execInfo := range nodeExecutions {
-		nodesRaw, _ := execInfo["nodes"].([]interface{})
-		execMessagesRaw, _ := execInfo["messages"].([]interface{})
 
-		var nodes []string
-		for _, n := range nodesRaw {
-			if s, ok := n.(string); ok {
-				nodes = append(nodes, s)
+// replayMessages replays session history using simple messages list.
+func (a *AgentHubACPAgent) replayMessages(sessionID string, messages []map[string]interface{}) {
+	// Pre-scan: collect tool results by name for including in tool_call events
+	toolResultsByName := make(map[string][]string)
+	for _, msg := range messages {
+		if msgType, _ := msg["type"].(string); msgType == "tool" {
+			toolName, _ := msg["name"].(string)
+			if toolName == "" {
+				toolName = "unknown"
 			}
-		}
-
-		var execMessages []map[string]interface{}
-		for _, m := range execMessagesRaw {
-			if mm, ok := m.(map[string]interface{}); ok {
-				execMessages = append(execMessages, mm)
+			if c, _ := msg["content"].(string); c != "" {
+				toolResultsByName[toolName] = append(toolResultsByName[toolName], c)
 			}
 		}
-
-		// Process messages in order: first emit human message, then AI/tool responses
-		humanEmitted := false
-		for _, msg := range execMessages {
-			msgType, _ := msg["type"].(string)
-			msgContent, _ := msg["content"].(string)
-			msgName, _ := msg["name"].(string)
-
-			if msgType == "human" {
-				// Emit user message
-				if msgContent != "" {
-					a.sendUserMessage(sessionID, msgContent)
-					humanEmitted = true
-				}
-				continue
-			}
-
-			// For AI and tool messages, check if this is a node output
-			if nodeSet := make(map[string]bool); len(nodes) > 0 {
-				for _, n := range nodes {
-					nodeSet[n] = true
-				}
-				if nodeSet[msgName] && msgContent != "" {
-					// This is a node output - emit as tool call + agent message
-					if !shownContents[msgContent] {
-						a.sendStartToolCall(sessionID, uuid.New().String(), msgName, nil, nil, "completed")
-						a.sendAgentMessage(sessionID, fmt.Sprintf("[%s]\n%s", msgName, msgContent))
-						shownContents[msgContent] = true
-					}
-					continue
-				}
-			}
-
-			// Handle AI messages with tool_calls
-			if msgType == "ai" {
-				if toolCallsRaw, ok := msg["tool_calls"].([]interface{}); ok {
-					for _, tc := range toolCallsRaw {
-						if tcm, ok := tc.(map[string]interface{}); ok {
-							tcName, _ := tcm["name"].(string)
-							if tcName == "" {
-								tcName = "unknown"
-							}
-							tcArgs := tcm["args"]
-							a.sendStartToolCall(sessionID, uuid.New().String(), tcName, tcArgs, nil, "completed")
-						}
-					}
-				}
-				if msgContent != "" && !shownContents[msgContent] {
-					a.sendAgentMessage(sessionID, msgContent)
-					shownContents[msgContent] = true
-				}
-			} else if msgType == "tool" {
-				toolName, _ := msg["name"].(string)
-				if toolName == "" {
-					toolName = "unknown"
-				}
-				if msgContent != "" && !shownContents[msgContent] {
-					a.sendAgentMessage(sessionID, fmt.Sprintf("[tool:%s] %s", toolName, msgContent))
-					shownContents[msgContent] = true
-				}
-			}
-		}
-
-		// If no human message was emitted but we have messages, something is wrong
-		// (this shouldn't happen with proper turn detection)
-		if !humanEmitted && len(execMessages) > 0 {
-			log.Printf("Warning: turn with no human message emitted, nodes=%v", nodes)
-		}
 	}
-}
+	toolResultIdx := make(map[string]int)
 
-// replayMessages replays session history using simple messages list.
-func (a *AgentHubACPAgent) replayMessages(sessionID string, messages []map[string]interface{}) {
 	for _, msg := range messages {
 		msgType, _ := msg["type"].(string)
 		msgContent, _ := msg["content"].(string)
+		msgName, _ := msg["name"].(string)
 
 		switch msgType {
 		case "human":
 			a.sendUserMessage(sessionID, msgContent)
 
 		case "ai":
-			// Handle tool_calls in AI messages
-			if toolCallsRaw, ok := msg["tool_calls"].([]interface{}); ok {
+			// Check if this AI message has tool_calls (ReAct Agent pattern)
+			if toolCallsRaw, ok := msg["tool_calls"].([]interface{}); ok && len(toolCallsRaw) > 0 {
+				// ReAct Agent pattern: AI message with tool_calls
 				for _, tc := range toolCallsRaw {
 					if tcm, ok := tc.(map[string]interface{}); ok {
 						tcName, _ := tcm["name"].(string)
@@ -447,20 +365,35 @@ func (a *AgentHubACPAgent) replayMessages(sessionID string, messages []map[strin
 							tcName = "unknown"
 						}
 						tcArgs := tcm["args"]
-						a.sendStartToolCall(sessionID, uuid.New().String(), tcName, tcArgs, nil, "completed")
+						tcID := uuid.New().String()
+						// Include tool output in the tool_call event
+						var rawOutput interface{}
+						if results, ok := toolResultsByName[tcName]; ok {
+							idx := toolResultIdx[tcName]
+							if idx < len(results) {
+								rawOutput = results[idx]
+								toolResultIdx[tcName] = idx + 1
+							}
+						}
+						a.sendStartToolCall(sessionID, tcID, tcName, tcArgs, rawOutput, "completed")
 					}
 				}
-			}
-			if msgContent != "" {
+				if msgContent != "" {
+					a.sendAgentMessage(sessionID, msgContent)
+				}
+			} else if msgName != "" && msgContent != "" {
+				// Node pattern: AI message without tool_calls, but has name (node name)
+				tcID := uuid.New().String()
+				a.sendStartToolCall(sessionID, tcID, msgName, nil, msgContent, "completed")
+				a.sendAgentMessage(sessionID, fmt.Sprintf("[%s]\n%s", msgName, msgContent))
+			} else if msgContent != "" {
+				// Regular AI message
 				a.sendAgentMessage(sessionID, msgContent)
 			}
 
 		case "tool":
-			toolName, _ := msg["name"].(string)
-			if toolName == "" {
-				toolName = "unknown"
-			}
-			a.sendAgentMessage(sessionID, fmt.Sprintf("[tool:%s] %s", toolName, msgContent))
+			// Tool results are already included in the preceding AI message's
+			// tool_call rawOutput, so skip standalone tool messages.
 		}
 	}
 }

{agent_api_server-2.1.10 → agent_api_server-2.1.12}/agent_api_server/api/v1/thread.py

@@ -626,7 +626,6 @@ async def get_thread_history(
     thread_id: str,
     limit: int = Query(50, ge=1, le=200, description="Max messages to return"),
     user_input_field: Optional[str] = Query(None, description="User input field name"),
-    include_node_history: bool = Query(False, description="Include node execution history"),
 ) -> Dict[str, Any]:
     try:
         from agent_api_server.memory.postgres import AsyncPostgresCheckpointer
@@ -706,155 +705,6 @@ async def get_thread_history(
             "next_config": state.next if hasattr(state, "next") else None,
         }
 
-        if include_node_history:
-            node_executions = []
-            snapshots = []
-            async for snapshot in graph_instance.aget_state_history(config):
-                snapshots.append(snapshot)
-            
-            snapshots.reverse()
-
-            from langchain_core.messages import HumanMessage as _HumanMessage
-
-            # Detect turns based on state history snapshots.
-            # Each snapshot represents a checkpoint; we detect new user
-            # inputs by comparing either string values or HumanMessage
-            # counts (when input_field points to a list like "messages").
-            turn_boundaries = []  # list of (msg_index_of_human_msg, user_text)
-
-            prev_human_count = 0
-            prev_user_input_str = None
-
-            for i, snapshot in enumerate(snapshots):
-                msgs = snapshot.values.get("messages", []) if snapshot.values else []
-                if not (snapshot.values and input_field):
-                    continue
-
-                val = snapshot.values.get(input_field)
-                current_user_input = None
-
-                if val and isinstance(val, str):
-                    current_user_input = val.strip()
-                    if (current_user_input is not None and
-                            current_user_input != prev_user_input_str):
-                        # Find the last HumanMessage in current msgs
-                        human_idx = None
-                        for j in range(len(msgs) - 1, -1, -1):
-                            if isinstance(msgs[j], _HumanMessage):
-                                human_idx = j
-                                break
-                        if human_idx is not None:
-                            turn_boundaries.append((human_idx, current_user_input))
-                    prev_user_input_str = current_user_input
-
-                elif isinstance(val, list):
-                    # input_field points to the messages list itself.
-                    # Find new HumanMessages by comparing count with previous snapshot.
-                    def _is_human_message(m):
-                        """Check if a message is a HumanMessage (supports both object and dict formats)."""
-                        if isinstance(m, _HumanMessage):
-                            return True
-                        if isinstance(m, dict) and m.get("type") == "human":
-                            return True
-                        if hasattr(m, "type") and getattr(m, "type", None) == "human":
-                            return True
-                        return False
-                    
-                    def _get_message_content(m):
-                        """Get content from a message (supports both object and dict formats)."""
-                        if isinstance(m, dict):
-                            return m.get("content", "")
-                        return m.content if hasattr(m, "content") else str(m)
-                    
-                    human_indices_in_msgs = [
-                        j for j, m in enumerate(val)
-                        if _is_human_message(m)
-                    ]
-                    human_count = len(human_indices_in_msgs)
-                    if human_count > prev_human_count:
-                        # New HumanMessage(s) detected.
-                        # Use the ACTUAL index in the messages list,
-                        # not human_count - 1 (which is wrong when AI/tool
-                        # messages are interspersed).
-                        for k in range(prev_human_count, human_count):
-                            actual_idx = human_indices_in_msgs[k]
-                            new_human = val[actual_idx]
-                            content_str = _get_message_content(new_human)
-                            if isinstance(content_str, str):
-                                content_str = content_str.strip()
-                            else:
-                                content_str = str(content_str)
-                            turn_boundaries.append((actual_idx, content_str))
-                    prev_human_count = human_count
-
-            # Deduplicate boundaries by msg index (keep first occurrence)
-            seen_indices = set()
-            unique_boundaries = []
-            for idx, text in turn_boundaries:
-                if idx not in seen_indices:
-                    seen_indices.add(idx)
-                    unique_boundaries.append((idx, text))
-            turn_boundaries = unique_boundaries
-
-            # Build node_executions from turn boundaries
-            final_snapshot = snapshots[-1] if snapshots else None
-            if final_snapshot and final_snapshot.values:
-                final_msgs = final_snapshot.values.get("messages", [])
-
-                # Collect all node names from all snapshots for each turn range
-                for turn_idx, (human_msg_idx, user_text) in enumerate(turn_boundaries):
-                    # Determine message range for this turn
-                    start_idx = human_msg_idx
-                    if turn_idx + 1 < len(turn_boundaries):
-                        end_idx = turn_boundaries[turn_idx + 1][0]
-                    else:
-                        end_idx = len(final_msgs)
-
-                    # Collect node names that executed in this turn's snapshots
-                    turn_nodes = []
-                    for snapshot in snapshots:
-                        s_msgs = snapshot.values.get("messages", []) if snapshot.values else []
-                        s_len = len(s_msgs)
-                        # This snapshot belongs to this turn if it overlaps
-                        # with the turn's message range
-                        if s_len > start_idx and (turn_idx + 1 >= len(turn_boundaries) or s_len <= end_idx + 1):
-                            node_names = [task.name for task in snapshot.tasks if task.name != "__start__"] if snapshot.tasks else []
-                            for n in node_names:
-                                if n not in turn_nodes:
-                                    turn_nodes.append(n)
-
-                    # Build turn messages
-                    turn_messages = [{
-                        "type": "human",
-                        "content": user_text,
-                        "name": None,
-                        "tool_calls": [],
-                    }]
-
-                    # Add non-human messages in range (skip the human message at start_idx
-                    # since we already added it above)
-                    for msg in final_msgs[start_idx + 1:end_idx]:
-                        turn_messages.append({
-                            "type": getattr(msg, "type", "unknown"),
-                            "content": msg.content if hasattr(msg, "content") else str(msg),
-                            "name": getattr(msg, "name", None),
-                            "tool_calls": [
-                                {"name": tc.get("name", ""), "args": tc.get("args", {})}
-                                for tc in (getattr(msg, "tool_calls", []) or [])
-                            ] if hasattr(msg, "tool_calls") else [],
-                        })
-
-                    node_executions.append({
-                        "step": turn_idx,
-                        "nodes": turn_nodes,
-                        "messages": turn_messages,
-                    })
-            elif not turn_boundaries:
-                # Fallback: no turn boundaries detected, use simple messages
-                pass
-
-            result["node_executions"] = node_executions
-
         return result
         
     except HTTPException:

{agent_api_server-2.1.10 → agent_api_server-2.1.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-api-server"
-version = "2.1.10"
+version = "2.1.12"
 description = "A Langgraph agent API server that implements Langgraph agent's web capabilities and can interact with chatbot"
 authors = [
     {name = "zijie.zhang@advantech.com.cn"}