feat(main-agent): superagent into main agent

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.test.tsx

@@ -49,12 +49,30 @@ describe('ToolCallItem', () => {
     const markup = renderToStaticMarkup(
       <ToolCallItem
         toolName='gmail_read_v2'
-        displayTitle='Gmail: Searching for invoice emails'
+        displayTitle='Searching for invoice emails'
         status='executing'
       />
     )
 
     expect(markup).toContain('<svg')
-    expect(markup).toContain('Gmail: Searching for invoice emails')
+    expect(markup).toContain('Searching for invoice emails')
+  })
+
+  it('renders the integration icon from a provisional gateway toolId', () => {
+    vi.mocked(getBlockByToolName).mockReturnValueOnce({
+      name: 'Gmail',
+      icon: (props: SVGProps<SVGSVGElement>) => <svg {...props} data-testid='gmail-icon' />,
+    } as ReturnType<typeof getBlockByToolName>)
+    const markup = renderToStaticMarkup(
+      <ToolCallItem
+        toolName='call_integration_tool'
+        displayTitle='Read recent emails'
+        status='executing'
+        streamingArgs='{"toolId":"gmail_read_v2","description":"Read recent emails"'
+      />
+    )
+
+    expect(markup).toContain('<svg')
+    expect(markup).toContain('Read recent emails')
   })
 })

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx

@@ -1,7 +1,12 @@
 import { useMemo } from 'react'
 import { ShimmerText } from '@/components/ui'
-import { Read as ReadTool, WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import {
+  CallIntegrationTool,
+  Read as ReadTool,
+  WorkspaceFile,
+} from '@/lib/copilot/generated/tool-catalog-v1'
 import { getReadTargetBlock } from '@/lib/copilot/tools/client/read-block'
+import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolCompletedTitle } from '@/lib/copilot/tools/tool-display'
 import { getBareIconStyle } from '@/blocks/icon-color'
 import { getBlockByToolName } from '@/blocks/registry'
@@ -53,6 +58,15 @@ export function ToolCallItem({
     return typeof path === 'string' ? getReadTargetBlock(path) : undefined
   }, [toolName, params])
 
+  // Like read's VFS-target resolution above, the gateway uses its exact
+  // discovered toolId only as a deterministic registry lookup. This renders
+  // the real integration brand while Go validates/resolves the operation.
+  const gatewayBlock = useMemo(() => {
+    if (toolName !== CallIntegrationTool.id) return undefined
+    const toolId = params?.toolId ?? extractStreamingStringArgument(streamingArgs, 'toolId')
+    return typeof toolId === 'string' ? getBlockByToolName(toolId) : undefined
+  }, [toolName, params, streamingArgs])
+
   const liveWorkspaceFileTitle = useMemo(() => {
     if (toolName !== WorkspaceFile.id || !streamingArgs) return null
     const titleMatch = streamingArgs.match(/"title"\s*:\s*"([^"]+)"/)
@@ -89,7 +103,7 @@ export function ToolCallItem({
       ? (getToolCompletedTitle(liveTitle) ?? liveTitle)
       : liveTitle
 
-  const BlockIcon = (readBlock ?? getBlockByToolName(toolName))?.icon
+  const BlockIcon = (readBlock ?? gatewayBlock ?? getBlockByToolName(toolName))?.icon
 
   return (
     <div className='flex items-center gap-[6px] pl-6'>

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts

@@ -21,6 +21,7 @@ import { dispatchStreamEvent } from './dispatch-stream-event'
 import { createStreamLoopContext, type StreamLoopContext } from './stream-context'
 import { makeStreamLoopDeps, ref } from './stream-test-helpers'
 import type { ToolNode } from './turn-model'
+import { contentBlocksToModel, modelToContentBlocks } from './turn-model-serialize'
 
 let seq = 0
 function toolEnv(payload: Record<string, unknown>): PersistedStreamEventEnvelope {
@@ -124,3 +125,127 @@ describe('tool events (dispatch → model + side effects)', () => {
     expect(toolNode(ctx, 'wf-1').status).toBe('success')
   })
 })
+
+describe('integration gateway (full wire sequence → published snapshot)', () => {
+  const GATEWAY = 'call_integration_tool'
+  const CALL_ID = 'ig-1'
+
+  const generating = () =>
+    toolEnv({
+      phase: 'call',
+      executor: 'go',
+      mode: 'sync',
+      toolCallId: CALL_ID,
+      toolName: GATEWAY,
+      status: 'generating',
+    })
+
+  const argsDelta = (argumentsDelta: string) =>
+    toolEnv({
+      phase: 'args_delta',
+      executor: 'go',
+      mode: 'sync',
+      toolCallId: CALL_ID,
+      toolName: GATEWAY,
+      argumentsDelta,
+    })
+
+  const gatewayFinalCall = () =>
+    toolEnv({
+      phase: 'call',
+      executor: 'go',
+      mode: 'sync',
+      toolCallId: CALL_ID,
+      toolName: GATEWAY,
+      arguments: {
+        toolId: 'gmail_read_v2',
+        description: 'Read recent emails',
+        arguments: { maxResults: 5 },
+      },
+    })
+
+  const resolvedOperationCall = () =>
+    toolEnv({
+      phase: 'call',
+      executor: 'sim',
+      mode: 'async',
+      toolCallId: CALL_ID,
+      toolName: 'gmail_read_v2',
+      arguments: { maxResults: 5, credentialId: 'cred-1' },
+    })
+
+  /** The exact toolCall snapshot the browser publishes for this row. */
+  function publishedToolCall(ctx: StreamLoopContext) {
+    const blocks = modelToContentBlocks(ctx.state.model)
+    const block = blocks.find((b) => b.type === 'tool_call' && b.toolCall?.id === CALL_ID)
+    expect(block?.toolCall).toBeDefined()
+    return block!.toolCall!
+  }
+
+  it('brands the row from streamed args while generating, then rebinds to the resolved operation', () => {
+    const ctx = createStreamLoopContext(makeStreamLoopDeps())
+
+    // Provisional frame: neutral label, never the humanized gateway name.
+    dispatchStreamEvent(ctx, generating())
+    expect(publishedToolCall(ctx).displayTitle).toBe('Calling integration')
+
+    // toolId alone brands only the icon (row component); text stays neutral.
+    dispatchStreamEvent(ctx, argsDelta('{"toolId":"gmail_read_v2",'))
+    expect(publishedToolCall(ctx).displayTitle).toBe('Calling integration')
+    expect(publishedToolCall(ctx).streamingArgs).toContain('"toolId":"gmail_read_v2"')
+
+    // The model-authored activity phrase becomes the row text as it completes.
+    dispatchStreamEvent(ctx, argsDelta('"description":"Read recent emails",'))
+    expect(publishedToolCall(ctx).displayTitle).toBe('Read recent emails')
+
+    dispatchStreamEvent(ctx, argsDelta('"arguments":{"maxResults":5}}'))
+    dispatchStreamEvent(ctx, gatewayFinalCall())
+    expect(publishedToolCall(ctx)).toEqual(
+      expect.objectContaining({
+        name: GATEWAY,
+        displayTitle: 'Read recent emails',
+      })
+    )
+
+    // Second authoritative frame (same call id): rebind to the exact operation.
+    dispatchStreamEvent(ctx, resolvedOperationCall())
+    const rebound = publishedToolCall(ctx)
+    expect(rebound).toEqual(
+      expect.objectContaining({
+        name: 'gmail_read_v2',
+        displayTitle: 'Read recent emails',
+        integrationDescription: 'Read recent emails',
+        params: { maxResults: 5, credentialId: 'cred-1' },
+      })
+    )
+    expect(rebound.streamingArgs).toBeUndefined()
+
+    dispatchStreamEvent(ctx, toolResult(CALL_ID, true, 'gmail_read_v2'))
+    expect(publishedToolCall(ctx)).toEqual(
+      expect.objectContaining({
+        name: 'gmail_read_v2',
+        status: 'success',
+        displayTitle: 'Read recent emails',
+      })
+    )
+  })
+
+  it('keeps the rebound branding across a snapshot rebuild (reconnect round-trip)', () => {
+    const ctx = createStreamLoopContext(makeStreamLoopDeps())
+    dispatchStreamEvent(ctx, generating())
+    dispatchStreamEvent(ctx, gatewayFinalCall())
+    dispatchStreamEvent(ctx, resolvedOperationCall())
+    dispatchStreamEvent(ctx, toolResult(CALL_ID, true, 'gmail_read_v2'))
+
+    const rebuilt = contentBlocksToModel(modelToContentBlocks(ctx.state.model))
+    const blocks = modelToContentBlocks(rebuilt)
+    const block = blocks.find((b) => b.type === 'tool_call' && b.toolCall?.id === CALL_ID)
+    expect(block?.toolCall).toEqual(
+      expect.objectContaining({
+        name: 'gmail_read_v2',
+        status: 'success',
+        displayTitle: 'Read recent emails',
+      })
+    )
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { isRecordLike } from '@sim/utils/object'
 import {
+  CallIntegrationTool,
   CrawlWebsite,
   CreateFile,
   CreateWorkflow,
@@ -29,6 +30,7 @@ import {
   WorkspaceFileOperation,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { VFS_DIR_TO_RESOURCE } from '@/lib/copilot/resources/types'
+import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolDisplayTitle, mvDisplayVerb } from '@/lib/copilot/tools/tool-display'
 import type { ContentBlock, MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
 import { ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
@@ -216,6 +218,33 @@ function functionExecuteTitle(title: string | undefined): string {
   return title ?? 'Running code'
 }
 
+/**
+ * Row text for an integration-gateway tool call: the model-authored activity
+ * `description`, readable the moment it completes in the still-streaming
+ * argument buffer — the same pattern `read`/`workspace_file` use for their
+ * streaming VFS targets. The trusted integration branding is the ICON, which
+ * the row component derives deterministically from the streamed `toolId` (or
+ * the rebound operation name) via Sim's block registry — the text carries no
+ * integration name. After Go's authoritative frame rebinds the row to the
+ * exact operation (e.g. `gmail_read_v2`), the preserved
+ * `integrationDescription` keeps the same text. Returns undefined until a
+ * description is readable (callers fall back to the neutral gateway label).
+ */
+export function resolveIntegrationToolDisplayTitle(tool: {
+  name: string
+  args?: Record<string, unknown>
+  streamingArgs?: string
+  integrationDescription?: string
+}): string | undefined {
+  if (tool.name === CallIntegrationTool.id) {
+    const description =
+      stringParam(tool.args?.description) ??
+      extractStreamingStringArgument(tool.streamingArgs, 'description')?.trim()
+    return description || undefined
+  }
+  return tool.integrationDescription
+}
+
 export function resolveToolDisplayTitle(name: string, args?: Record<string, unknown>): string {
   // Cases that enrich the title with live workspace/block names from the client
   // stores. Everything else is resolved by the shared name+args resolver, which

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.ts

@@ -1,5 +1,6 @@
 import type { PersistedStreamEventEnvelope } from '@/lib/copilot/request/session/contract'
 import {
+  resolveIntegrationToolDisplayTitle,
   resolveStreamingToolDisplayTitle,
   resolveToolDisplayTitle,
 } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers'
@@ -38,10 +39,14 @@ function toolStatusToNode(status: ToolCallStatus): NodeStatus {
 
 /**
  * Resolves a tool row's display title with the same precedence the live handler
- * used: the streaming-args title wins while args stream, then the arg-derived
- * title, then the explicit `ui.title`.
+ * used: the integration gateway's model-authored activity description first
+ * (live even mid-argument-stream; the integration brand is the row icon), then
+ * the streaming-args title while args stream, then the arg-derived title, then
+ * the explicit `ui.title`.
  */
 function toolDisplayTitle(node: ToolNode): string | undefined {
+  const integrationTitle = resolveIntegrationToolDisplayTitle(node)
+  if (integrationTitle) return integrationTitle
   const streamingTitle = node.streamingArgs
     ? resolveStreamingToolDisplayTitle(node.name, node.streamingArgs)
     : undefined
@@ -126,6 +131,9 @@ export function modelToContentBlocks(model: TurnModel): ContentBlock[] {
             name: node.name,
             status: nodeToToolStatus(node.status),
             ...(displayTitle ? { displayTitle } : {}),
+            ...(node.integrationDescription
+              ? { integrationDescription: node.integrationDescription }
+              : {}),
             ...(node.args ? { params: node.args } : {}),
             ...(node.streamingArgs ? { streamingArgs: node.streamingArgs } : {}),
             ...(node.result
@@ -292,6 +300,11 @@ export function contentBlocksToModel(blocks: ContentBlock[]): TurnModel {
             arguments: tc.params,
             // Preserve a server-provided title that isn't derivable from args.
             ...(tc.displayTitle ? { ui: { title: tc.displayTitle } } : {}),
+            // Rebound gateway rows keep their model-authored activity phrase
+            // across a snapshot rebuild (the resolved args no longer carry it).
+            ...(tc.integrationDescription
+              ? { integrationDescription: tc.integrationDescription }
+              : {}),
           },
           scopeFor(block),
           block.timestamp

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts

@@ -8,7 +8,9 @@ import {
   MothershipStreamV1SpanPayloadKind,
   MothershipStreamV1ToolPhase,
 } from '@/lib/copilot/generated/mothership-stream-v1'
+import { CallIntegrationTool } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { PersistedStreamEventEnvelope } from '@/lib/copilot/request/session/contract'
+import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { CONTEXT_COMPACTION_DISPLAY_TITLE } from '@/lib/copilot/tools/tool-display'
 
 /**
@@ -56,6 +58,13 @@ export interface ToolNode extends NodeBase {
   args?: Record<string, unknown>
   streamingArgs?: string
   uiTitle?: string
+  /**
+   * Model-authored activity phrase for a gateway-resolved integration call
+   * (e.g. "Reading recent emails"). Captured when the authoritative resolved
+   * frame rebinds the node's name to the exact operation, because the resolved
+   * args no longer carry the gateway's `description` field.
+   */
+  integrationDescription?: string
   /** Per-call `ui.hidden` flag — the node is tracked for side effects but not rendered. */
   hidden?: boolean
   result?: { success: boolean; output?: unknown; error?: string }
@@ -181,6 +190,26 @@ function asString(value: unknown): string | undefined {
   return typeof value === 'string' ? value : undefined
 }
 
+/**
+ * The integration gateway intentionally emits a second authoritative call frame
+ * under the SAME provider call id once Go resolves the exact server-owned
+ * operation (call_integration_tool -> e.g. gmail_read_v2). Rebind the node to
+ * that operation so the row brands from the real integration (name -> block
+ * registry) and keep only the model-authored `description` for presentation —
+ * the caller then replaces args with the resolved operation args, which no
+ * longer carry the gateway envelope fields.
+ */
+function rebindResolvedIntegrationCall(node: ToolNode, toolName: string): void {
+  if (node.name !== CallIntegrationTool.id) return
+  if (!toolName || toolName === CallIntegrationTool.id) return
+  const description =
+    asString(node.args?.description)?.trim() ||
+    extractStreamingStringArgument(node.streamingArgs, 'description')?.trim()
+  if (description) node.integrationDescription = description
+  node.name = toolName
+  node.streamingArgs = undefined
+}
+
 /**
  * Reads a wire event payload as a generic record. The payload is a wide
  * discriminated union; the reducer accesses fields uniformly, so this narrows
@@ -474,7 +503,13 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
           seq,
           tsMs
         )
+        rebindResolvedIntegrationCall(node, toolName)
         if (isRecord(payload.arguments)) node.args = payload.arguments
+        // Only the snapshot-replay path (contentBlocksToModel) carries this
+        // field — the live wire never does; it restores the rebound gateway
+        // description across a preserve-state rebuild.
+        const restoredDescription = asString(payload.integrationDescription)
+        if (restoredDescription) node.integrationDescription = restoredDescription
         // Tool-call titles are derived from the tool name (+args) at serialize
         // time; the stream only carries behavioral flags now.
         const ui = isRecord(payload.ui) ? payload.ui : undefined

apps/sim/app/workspace/[workspaceId]/home/types.ts

@@ -73,6 +73,8 @@ export interface ToolCallInfo {
   name: string
   status: ToolCallStatus
   displayTitle?: string
+  /** Model-authored activity phrase for a gateway-resolved integration call. */
+  integrationDescription?: string
   params?: Record<string, unknown>
   calledBy?: string
   result?: ToolCallResult

apps/sim/lib/copilot/generated/tool-catalog-v1.ts

@@ -268,7 +268,7 @@ export const CallIntegrationTool: ToolCatalogEntry = {
       },
       description: {
         description:
-          'Short present-progressive UI phrase describing this invocation, without the integration name (for example "Searching for invoice emails").',
+          'Short base-form verb phrase describing this invocation, without the integration name (for example "Search for invoice emails").',
         type: 'string',
       },
       toolId: { description: 'Exact toolId returned by search_integration_tools.', type: 'string' },

apps/sim/lib/copilot/generated/tool-schemas-v1.ts

@@ -51,7 +51,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         },
         description: {
           description:
-            'Short present-progressive UI phrase describing this invocation, without the integration name (for example "Searching for invoice emails").',
+            'Short base-form verb phrase describing this invocation, without the integration name (for example "Search for invoice emails").',
           type: 'string',
         },
         toolId: {