Plan respond plan

Author: Sg312

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/copilot/components/tool-call/tool-call.tsx

@@ -26,9 +26,6 @@ import { CLASS_TOOL_METADATA } from '@/stores/panel/copilot/store'
 import type { SubAgentContentBlock } from '@/stores/panel/copilot/types'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
 
-/**
- * Parse special tags from content
- */
 /**
  * Plan step can be either a string or an object with title and plan
  */
@@ -47,6 +44,62 @@ interface ParsedTags {
   cleanContent: string
 }
 
+/**
+ * Extract plan steps from plan_respond tool calls in subagent blocks.
+ * Returns { steps, isComplete } where steps is in the format expected by PlanSteps component.
+ */
+function extractPlanFromBlocks(blocks: SubAgentContentBlock[] | undefined): {
+  steps: Record<string, PlanStep> | undefined
+  isComplete: boolean
+} {
+  if (!blocks) return { steps: undefined, isComplete: false }
+
+  // Find the plan_respond tool call
+  const planRespondBlock = blocks.find(
+    (b) => b.type === 'subagent_tool_call' && b.toolCall?.name === 'plan_respond'
+  )
+
+  if (!planRespondBlock?.toolCall) {
+    return { steps: undefined, isComplete: false }
+  }
+
+  // Tool call arguments can be in different places depending on the source
+  // Also handle nested data.arguments structure from the schema
+  const tc = planRespondBlock.toolCall as any
+  const args =
+    tc.params ||
+    tc.parameters ||
+    tc.input ||
+    tc.arguments ||
+    tc.data?.arguments ||
+    {}
+  const stepsArray = args.steps
+
+  if (!Array.isArray(stepsArray) || stepsArray.length === 0) {
+    return { steps: undefined, isComplete: false }
+  }
+
+  // Convert array format to Record<string, PlanStep> format
+  // From: [{ number: 1, title: "..." }, { number: 2, title: "..." }]
+  // To: { "1": "...", "2": "..." }
+  const steps: Record<string, PlanStep> = {}
+  for (const step of stepsArray) {
+    if (step.number !== undefined && step.title) {
+      steps[String(step.number)] = step.title
+    }
+  }
+
+  // Check if the tool call is complete (not pending/executing)
+  const isComplete =
+    planRespondBlock.toolCall.state === ClientToolCallState.success ||
+    planRespondBlock.toolCall.state === ClientToolCallState.error
+
+  return {
+    steps: Object.keys(steps).length > 0 ? steps : undefined,
+    isComplete,
+  }
+}
+
 /**
  * Try to parse partial JSON for streaming options.
  * Attempts to extract complete key-value pairs from incomplete JSON.
@@ -1094,17 +1147,12 @@ function SubAgentContent({
         })}
       </div>
 
-      {/* Render PlanSteps for plan subagent when content contains <plan> tag */}
+      {/* Render PlanSteps for plan subagent when plan_respond tool is present */}
       {toolName === 'plan' &&
         (() => {
-          // Combine all text content from blocks
-          const allText = blocks
-            .filter((b) => b.type === 'subagent_text' && b.content)
-            .map((b) => b.content)
-            .join('')
-          const parsed = parseSpecialTags(allText)
-          if (parsed.plan && Object.keys(parsed.plan).length > 0) {
-            return <PlanSteps steps={parsed.plan} streaming={!isThinkingDone} />
+          const { steps, isComplete } = extractPlanFromBlocks(blocks)
+          if (steps && Object.keys(steps).length > 0) {
+            return <PlanSteps steps={steps} streaming={!isComplete} />
           }
           return null
         })()}
@@ -1124,23 +1172,19 @@ function SubAgentThinkingContent({
   isStreaming?: boolean
 }) {
   // Combine all text content from blocks
-  let allRawText = ''
   let cleanText = ''
   for (const block of blocks) {
     if (block.type === 'subagent_text' && block.content) {
-      allRawText += block.content
       const parsed = parseSpecialTags(block.content)
       cleanText += parsed.cleanContent
     }
   }
 
-  // Parse plan from all text
-  const allParsed = parseSpecialTags(allRawText)
+  // Extract plan from plan_respond tool call
+  const { steps: planSteps, isComplete: planComplete } = extractPlanFromBlocks(blocks)
+  const hasPlan = !!(planSteps && Object.keys(planSteps).length > 0)
 
-  if (!cleanText.trim() && !allParsed.plan) return null
-
-  // Check if special tags are present
-  const hasSpecialTags = !!(allParsed.plan && Object.keys(allParsed.plan).length > 0)
+  if (!cleanText.trim() && !hasPlan) return null
 
   return (
     <div className='space-y-1.5'>
@@ -1149,12 +1193,10 @@ function SubAgentThinkingContent({
           content={cleanText}
           isStreaming={isStreaming}
           hasFollowingContent={false}
-          hasSpecialTags={hasSpecialTags}
+          hasSpecialTags={hasPlan}
         />
       )}
-      {allParsed.plan && Object.keys(allParsed.plan).length > 0 && (
-        <PlanSteps steps={allParsed.plan} streaming={isStreaming} />
-      )}
+      {hasPlan && <PlanSteps steps={planSteps} streaming={!planComplete} />}
     </div>
   )
 }
@@ -1235,11 +1277,17 @@ function SubagentContentRenderer({
     segments.push({ type: 'text', content: currentText })
   }
 
-  // Parse plan and options
+  // Parse options from text (plan is extracted from tool call)
   const allParsed = parseSpecialTags(allRawText)
+
+  // Extract plan from plan_respond tool call
+  const { steps: planSteps, isComplete: planComplete } = extractPlanFromBlocks(
+    toolCall.subAgentBlocks
+  )
+  const hasPlan = !!(planSteps && Object.keys(planSteps).length > 0)
+
   const hasSpecialTags = !!(
-    (allParsed.plan && Object.keys(allParsed.plan).length > 0) ||
-    (allParsed.options && Object.keys(allParsed.options).length > 0)
+    hasPlan || (allParsed.options && Object.keys(allParsed.options).length > 0)
   )
 
   const formatDuration = (ms: number) => {
@@ -1251,9 +1299,6 @@ function SubagentContentRenderer({
   const outerLabel = getSubagentCompletionLabel(toolCall.name)
   const durationText = `${outerLabel} for ${formatDuration(duration)}`
 
-  // Check if we have a plan to render outside the collapsible
-  const hasPlan = allParsed.plan && Object.keys(allParsed.plan).length > 0
-
   // Render the collapsible content (thinking blocks + tool calls, NOT plan)
   // Inner thinking text always uses "Thought" label
   const renderCollapsibleContent = () => (
@@ -1299,7 +1344,7 @@ function SubagentContentRenderer({
     return (
       <div className='w-full space-y-1.5'>
         {renderCollapsibleContent()}
-        {hasPlan && <PlanSteps steps={allParsed.plan!} streaming={isStreaming} />}
+        {hasPlan && <PlanSteps steps={planSteps!} streaming={!planComplete} />}
       </div>
     )
   }
@@ -1333,7 +1378,7 @@ function SubagentContentRenderer({
       </div>
 
       {/* Plan stays outside the collapsible */}
-      {hasPlan && <PlanSteps steps={allParsed.plan!} />}
+      {hasPlan && <PlanSteps steps={planSteps!} />}
     </div>
   )
 }
@@ -1958,7 +2003,10 @@ export function ToolCall({ toolCall: toolCallProp, toolCallId, onStateChange }:
     toolCall.name === 'checkoff_todo' ||
     toolCall.name === 'mark_todo_in_progress' ||
     toolCall.name === 'tool_search_tool_regex' ||
-    toolCall.name === 'user_memory'
+    toolCall.name === 'user_memory' ||
+    toolCall.name === 'edit_responsd' ||
+    toolCall.name === 'debug_respond' ||
+    toolCall.name === 'plan_respond'
   )
     return null
 

apps/sim/lib/copilot/tools/server/workflow/edit-workflow.ts

@@ -966,7 +966,10 @@ function validateConditionHandle(
       if (elseIfIndex === 0) {
         handleToNormalized.set(`${legacySemanticPrefix}else-if`, normalizedHandle)
       } else {
-        handleToNormalized.set(`${legacySemanticPrefix}else-if-${elseIfIndex + 1}`, normalizedHandle)
+        handleToNormalized.set(
+          `${legacySemanticPrefix}else-if-${elseIfIndex + 1}`,
+          normalizedHandle
+        )
       }
       elseIfIndex++
     } else if (title === 'else') {

apps/sim/lib/workflows/sanitization/json-sanitizer.ts

@@ -330,11 +330,7 @@ function convertConditionHandleToSimple(
  * Convert internal router handle (router-{uuid}) to simple format (route-0, route-1)
  * Uses 0-indexed numbering for routes
  */
-function convertRouterHandleToSimple(
-  handle: string,
-  _blockId: string,
-  block: BlockState
-): string {
+function convertRouterHandleToSimple(handle: string, _blockId: string, block: BlockState): string {
   if (!handle.startsWith('router-')) {
     return handle
   }