@poncho-ai/cli 0.32.4 → 0.32.5

package/src/web-ui-client.ts

@@ -32,6 +32,7 @@ export const getWebUiClientScript = (markedSource: string): string => `
         todoPanelCollapsed: false,
         cronSectionCollapsed: true,
         cronShowAll: false,
+        subagentPollInFlight: {},
       };
 
       const agentInitial = document.body.dataset.agentInitial || "A";
@@ -491,11 +492,20 @@ export const getWebUiClientScript = (markedSource: string): string => `
               return null;
             }
             const toolName = item && typeof item.tool === "string" ? item.tool : "tool";
+            const decision =
+              item && typeof item.decision === "string" ? item.decision : null;
+            const isResolved = decision === "approved" || decision === "denied";
             return {
               approvalId,
               tool: toolName,
               input: item?.input ?? {},
-              state: "pending",
+              state: isResolved ? "resolved" : "pending",
+              resolvedDecision:
+                decision === "approved"
+                  ? "approve"
+                  : decision === "denied"
+                    ? "deny"
+                    : null,
             };
           })
           .filter(Boolean);
@@ -1545,8 +1555,8 @@ export const getWebUiClientScript = (markedSource: string): string => `
               updateContextRing();
               renderMessages(state.activeMessages, payload.hasActiveRun);
             }
-            if (payload.hasActiveRun) {
-              if (window._connectBrowserStream) window._connectBrowserStream();
+            if (payload.hasActiveRun || payload.hasRunningSubagents) {
+              if (payload.hasActiveRun && window._connectBrowserStream) window._connectBrowserStream();
               setTimeout(poll, 2000);
             } else {
               setStreaming(false);
@@ -1561,9 +1571,15 @@ export const getWebUiClientScript = (markedSource: string): string => `
       };
 
       const pollForSubagentResults = (conversationId) => {
+        if (state.subagentPollInFlight[conversationId]) return;
+        state.subagentPollInFlight[conversationId] = true;
         let lastMessageCount = state.activeMessages ? state.activeMessages.length : 0;
+        let lastUpdatedAt = 0;
         const poll = async () => {
-          if (state.activeConversationId !== conversationId) return;
+          if (state.activeConversationId !== conversationId) {
+            delete state.subagentPollInFlight[conversationId];
+            return;
+          }
           try {
             var payload = await api("/api/conversations/" + encodeURIComponent(conversationId));
             if (state.activeConversationId !== conversationId) return;
@@ -1584,13 +1600,17 @@ export const getWebUiClientScript = (markedSource: string): string => `
                   });
                 });
               }
-              if (messages.length > lastMessageCount) {
+              const conversationUpdatedAt =
+                typeof payload.conversation.updatedAt === "number" ? payload.conversation.updatedAt : 0;
+              if (messages.length > lastMessageCount || conversationUpdatedAt > lastUpdatedAt) {
                 lastMessageCount = messages.length;
+                lastUpdatedAt = conversationUpdatedAt;
                 state.activeMessages = hydratePendingApprovals(messages, allPending);
                 renderMessages(state.activeMessages, payload.hasActiveRun || payload.hasRunningSubagents);
               }
               if (payload.hasActiveRun) {
                 // Parent agent started its continuation run — switch to live stream
+                delete state.subagentPollInFlight[conversationId];
                 setStreaming(true);
                 state.activeMessages = hydratePendingApprovals(messages, allPending);
                 streamConversationEvents(conversationId, { liveOnly: true }).finally(() => {
@@ -1603,6 +1623,7 @@ export const getWebUiClientScript = (markedSource: string): string => `
               } else {
                 renderMessages(state.activeMessages, false);
                 await loadConversations();
+                delete state.subagentPollInFlight[conversationId];
               }
             }
           } catch {
@@ -2530,6 +2551,7 @@ export const getWebUiClientScript = (markedSource: string): string => `
           let _maxSteps = 0;
           let _receivedTerminalEvent = false;
           let _shouldContinue = false;
+          let _pendingSubagentsConversation = null;
 
           // Helper to read an SSE stream from a fetch response
           const readSseStream = async (response) => {
@@ -2847,7 +2869,7 @@ export const getWebUiClientScript = (markedSource: string): string => `
                       assistantMessage.content = String(payload.result?.response || "");
                     }
                     if (payload.pendingSubagents) {
-                      pollForSubagentResults(conversationId);
+                      _pendingSubagentsConversation = conversationId;
                     }
                     renderIfActiveConversation(false);
                   }
@@ -2975,6 +2997,19 @@ export const getWebUiClientScript = (markedSource: string): string => `
           }
           elements.prompt.focus();
         }
+
+        // Subagent callback: after sendMessage fully completes (including
+        // finally cleanup), reload the conversation. loadConversation is
+        // the exact same code path as a manual refresh — if the callback
+        // is still running it connects to the event stream; if it already
+        // finished it just renders the final persisted state.
+        if (_pendingSubagentsConversation && state.activeConversationId === _pendingSubagentsConversation) {
+          const cbConvId = _pendingSubagentsConversation;
+          await new Promise(r => setTimeout(r, 1200));
+          if (state.activeConversationId === cbConvId && !state.isStreaming) {
+            await loadConversation(cbConvId);
+          }
+        }
       };
 
       const requireAuth = async () => {
@@ -3208,9 +3243,22 @@ export const getWebUiClientScript = (markedSource: string): string => `
         }));
         return api("/api/approvals/" + encodeURIComponent(approvalId), {
           method: "POST",
-          body: JSON.stringify({ approved: decision === "approve" }),
+          body: JSON.stringify({
+            approved: decision === "approve",
+            conversationId: state.activeConversationId || undefined,
+          }),
         }).catch((error) => {
           const isStale = error && error.payload && error.payload.code === "APPROVAL_NOT_FOUND";
+          const isNotReady = error && error.payload && error.payload.code === "APPROVAL_NOT_READY";
+          if (isNotReady) {
+            updatePendingApproval(approvalId, (request) => ({
+              ...request,
+              state: "pending",
+              pendingDecision: null,
+              resolvedDecision: null,
+            }));
+            return;
+          }
           if (isStale) {
             updatePendingApproval(approvalId, () => null);
           } else {
@@ -3281,9 +3329,23 @@ export const getWebUiClientScript = (markedSource: string): string => `
             for (const aid of pending) {
               await api("/api/approvals/" + encodeURIComponent(aid), {
                 method: "POST",
-                body: JSON.stringify({ approved: decision === "approve" }),
+                body: JSON.stringify({
+                  approved: decision === "approve",
+                  conversationId: state.activeConversationId || undefined,
+                }),
               }).catch((error) => {
                 const isStale = error && error.payload && error.payload.code === "APPROVAL_NOT_FOUND";
+                const isNotReady = error && error.payload && error.payload.code === "APPROVAL_NOT_READY";
+                if (isNotReady) {
+                  updatePendingApproval(aid, (request) => ({
+                    ...request,
+                    state: "pending",
+                    pendingDecision: null,
+                    resolvedDecision: null,
+                  }));
+                  renderMessages(state.activeMessages, state.isStreaming);
+                  return;
+                }
                 if (isStale) {
                   updatePendingApproval(aid, () => null);
                 } else {

package/test/run-orchestration.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "vitest";
+import type { AgentEvent, Message } from "@poncho-ai/sdk";
+import { __internalRunOrchestration } from "../src/index.js";
+
+const baseMessages: Message[] = [{ role: "user", content: "hello" }];
+
+describe("run orchestration helpers", () => {
+  it("falls back to user messages when harness history is unavailable", () => {
+    const conversation = {
+      messages: baseMessages,
+      _harnessMessages: "invalid",
+    };
+    const resolved = __internalRunOrchestration.loadRunHistory(
+      conversation as unknown as { messages: Message[]; _harnessMessages?: unknown; _continuationMessages?: unknown },
+    );
+    expect(resolved.source).toBe("messages");
+    expect(resolved.shouldRebuildCanonical).toBe(true);
+    expect(resolved.messages).toEqual(baseMessages);
+  });
+
+  it("prefers continuation history when requested", () => {
+    const continuation: Message[] = [{ role: "assistant", content: "next" }];
+    const conversation = {
+      messages: baseMessages,
+      _harnessMessages: baseMessages,
+      _continuationMessages: continuation,
+    };
+    const resolved = __internalRunOrchestration.loadRunHistory(
+      conversation as unknown as { messages: Message[]; _harnessMessages?: unknown; _continuationMessages?: unknown },
+      { preferContinuation: true },
+    );
+    expect(resolved.source).toBe("continuation");
+    expect(resolved.messages).toEqual(continuation);
+  });
+
+  it("normalizes legacy approval checkpoint payloads", () => {
+    const normalized = __internalRunOrchestration.normalizeApprovalCheckpoint(
+      {
+        approvalId: "approval_1",
+        runId: "run_1",
+        tool: "read_file",
+        toolCallId: "tool_1",
+        input: {},
+        checkpointMessages: undefined,
+        baseMessageCount: -1,
+        pendingToolCalls: [{ id: "t2", name: "list_directory", input: {} }, { foo: "bar" }],
+      } as unknown as {
+        approvalId: string;
+        runId: string;
+        tool: string;
+        toolCallId?: string;
+        input: Record<string, unknown>;
+        checkpointMessages?: Message[];
+        baseMessageCount?: number;
+        pendingToolCalls?: Array<{ id: string; name: string; input: Record<string, unknown> }>;
+        decision?: "approved" | "denied";
+      },
+      baseMessages,
+    );
+    expect(normalized.checkpointMessages).toEqual(baseMessages);
+    expect(normalized.baseMessageCount).toBe(0);
+    expect(normalized.pendingToolCalls).toEqual([{ id: "t2", name: "list_directory", input: {} }]);
+  });
+
+  it("builds checkpoint approvals with a canonical shape", () => {
+    const checkpoints = __internalRunOrchestration.buildApprovalCheckpoints({
+      approvals: [
+        {
+          approvalId: "approval_1",
+          tool: "read_file",
+          toolCallId: "tool_1",
+          input: { path: "README.md" },
+        },
+      ],
+      runId: "run_1",
+      checkpointMessages: baseMessages,
+      baseMessageCount: 2,
+      pendingToolCalls: [{ id: "tool_2", name: "list_directory", input: {} }],
+    });
+    expect(checkpoints).toEqual([
+      {
+        approvalId: "approval_1",
+        runId: "run_1",
+        tool: "read_file",
+        toolCallId: "tool_1",
+        input: { path: "README.md" },
+        checkpointMessages: baseMessages,
+        baseMessageCount: 2,
+        pendingToolCalls: [{ id: "tool_2", name: "list_directory", input: {} }],
+      },
+    ]);
+  });
+
+  it("resolves run request by preferring continuation and preserves rebuild signal", () => {
+    const continuation: Message[] = [{ role: "assistant", content: "continuation" }];
+    const resolved = __internalRunOrchestration.resolveRunRequest(
+      {
+        messages: baseMessages,
+        _harnessMessages: "invalid",
+        _continuationMessages: continuation,
+      } as unknown as { messages: Message[]; _harnessMessages?: unknown; _continuationMessages?: unknown },
+      {
+        conversationId: "conv_1",
+        messages: baseMessages,
+        preferContinuation: true,
+      },
+    );
+    expect(resolved.source).toBe("continuation");
+    expect(resolved.messages).toEqual(continuation);
+    expect(resolved.shouldRebuildCanonical).toBe(true);
+  });
+
+  it("records standard draft events for tool timeline and text", () => {
+    const draft = __internalRunOrchestration.createTurnDraftState();
+    __internalRunOrchestration.recordStandardTurnEvent(
+      draft,
+      { type: "tool:started", runId: "run_1", step: 1, tool: "read_file", input: {} } as AgentEvent,
+    );
+    __internalRunOrchestration.recordStandardTurnEvent(
+      draft,
+      { type: "tool:completed", runId: "run_1", step: 1, tool: "read_file", duration: 42, output: {} } as AgentEvent,
+    );
+    __internalRunOrchestration.recordStandardTurnEvent(
+      draft,
+      { type: "model:chunk", runId: "run_1", step: 1, content: "done" } as AgentEvent,
+    );
+    expect(draft.toolTimeline).toEqual(["- start `read_file`", "- done `read_file` (42ms)"]);
+    expect(draft.assistantResponse).toBe("done");
+  });
+
+  it("executes a conversation turn through the shared executor", async () => {
+    const events: AgentEvent[] = [
+      { type: "run:started", runId: "run_1", startedAt: Date.now() } as AgentEvent,
+      { type: "tool:started", runId: "run_1", step: 1, tool: "list_directory", input: {} } as AgentEvent,
+      { type: "model:chunk", runId: "run_1", step: 1, content: "hello" } as AgentEvent,
+      {
+        type: "run:completed",
+        runId: "run_1",
+        result: {
+          status: "completed",
+          response: "hello",
+          steps: 2,
+          duration: 10,
+          continuation: false,
+          continuationMessages: baseMessages,
+          usage: { inputTokens: 1, outputTokens: 1 },
+          contextTokens: 321,
+          contextWindow: 1000,
+        },
+      } as AgentEvent,
+    ];
+    const fakeHarness = {
+      async *runWithTelemetry() {
+        for (const event of events) yield event;
+      },
+    };
+    const seenTypes: string[] = [];
+    const result = await __internalRunOrchestration.executeConversationTurn({
+      harness: fakeHarness as never,
+      runInput: { task: "test", messages: baseMessages, conversationId: "conv_1" } as never,
+      onEvent: (event) => {
+        seenTypes.push(event.type);
+      },
+    });
+    expect(result.latestRunId).toBe("run_1");
+    expect(result.runSteps).toBe(2);
+    expect(result.runContextTokens).toBe(321);
+    expect(result.draft.assistantResponse).toBe("hello");
+    expect(seenTypes).toEqual(["run:started", "tool:started", "model:chunk", "run:completed"]);
+  });
+});