feat(copilot): attribute Sim tool calls to agents

Author: j15z

apps/sim/lib/copilot/request/handlers/handlers.test.ts

@@ -408,6 +408,7 @@ describe('sse-handlers tool lifecycle', () => {
 
     const updated = context.toolCalls.get('tool-1')
     expect(updated?.status).toBe(MothershipStreamV1ToolOutcome.success)
+    expect(updated?.agentId).toBe('main')
     // Display titles are derived client-side from the tool name (+args), not the
     // stream; read with no path resolves to the static "Reading file".
     expect(updated?.displayTitle).toBe('Reading file')
@@ -889,9 +890,11 @@ describe('sse-handlers tool lifecycle', () => {
       expect.any(Object)
     )
     expect(context.toolCalls.get('sub-tool-1')?.params).toEqual({ name: 'Example Workflow' })
+    expect(context.toolCalls.get('sub-tool-1')?.agentId).toBe('workflow')
     expect(context.subAgentToolCalls['parent-1']?.[0]?.params).toEqual({
       name: 'Example Workflow',
     })
+    expect(context.subAgentToolCalls['parent-1']?.[0]?.agentId).toBe('workflow')
   })
 
   it('routes subagent text using the event scope parent tool call id', async () => {
@@ -973,6 +976,40 @@ describe('sse-handlers tool lifecycle', () => {
     await sleep(0)
 
     expect(context.subAgentToolCalls['parent-1']?.[0]?.id).toBe('sub-tool-scope-1')
+    expect(context.toolCalls.get('sub-tool-scope-1')?.agentId).toBe('deploy')
+  })
+
+  it('retains the first agent attribution on replayed partial tool calls', async () => {
+    context.toolCalls.set('replayed-read', {
+      id: 'replayed-read',
+      name: 'read',
+      status: 'executing',
+    })
+
+    const replayPartial = (agentId: string) =>
+      subAgentHandlers.tool(
+        {
+          type: MothershipStreamV1EventType.tool,
+          scope: { lane: 'subagent', parentToolCallId: 'parent-1', agentId },
+          payload: {
+            toolCallId: 'replayed-read',
+            toolName: 'read',
+            executor: MothershipStreamV1ToolExecutor.go,
+            mode: MothershipStreamV1ToolMode.sync,
+            phase: MothershipStreamV1ToolPhase.call,
+            status: 'generating',
+            partial: true,
+          },
+        } satisfies StreamEvent,
+        context,
+        execContext,
+        { interactive: false, timeout: 1000 }
+      )
+
+    await replayPartial('workflow')
+    await replayPartial('deploy')
+
+    expect(context.toolCalls.get('replayed-read')?.agentId).toBe('workflow')
   })
 
   it('pairs compaction lifecycle events within each scoped subagent lane', async () => {

apps/sim/lib/copilot/request/handlers/tool.ts

@@ -285,6 +285,7 @@ export async function handleToolEvent(
 ): Promise<void> {
   const isSubagent = scope === 'subagent'
   const parentToolCallId = isSubagent ? getScopedParentToolCallId(event, context) : undefined
+  const agentId = event.scope?.agentId ?? 'main'
 
   if (isSubagent && !parentToolCallId) return
 
@@ -332,6 +333,7 @@ export async function handleToolEvent(
     options,
     parentToolCallId,
     scope,
+    agentId,
     getScopedSpanIdentity(event)
   )
 }
@@ -409,13 +411,15 @@ async function handleCallPhase(
   options: OrchestratorOptions,
   parentToolCallId: string | undefined,
   scope: ToolScope,
+  agentId: string,
   spanIdentity: { spanId?: string; parentSpanId?: string }
 ): Promise<void> {
   const { toolCallId, toolName } = data
   const args = data.arguments
   const isGenerating = data.status === TOOL_CALL_STATUS.generating
   const isPartial = data.partial === true || isGenerating
   const existing = context.toolCalls.get(toolCallId)
+  if (existing) existing.agentId ??= agentId
   const isSubagent = scope === 'subagent'
   const ui = getToolCallUI(data)
 
@@ -459,12 +463,13 @@ async function handleCallPhase(
       toolName,
       args,
       parentToolCallId!,
+      agentId,
       ui,
       spanIdentity,
       !isPartial
     )
   } else {
-    registerMainToolCall(context, toolCallId, toolName, args, existing, ui, !isPartial)
+    registerMainToolCall(context, toolCallId, toolName, args, existing, agentId, ui, !isPartial)
   }
 
   if (isPartial) return
@@ -554,6 +559,7 @@ function registerSubagentToolCall(
   toolName: string,
   args: Record<string, unknown> | undefined,
   parentToolCallId: string,
+  agentId: string,
   ui: { title?: string; phaseLabel?: string; hidden?: boolean },
   spanIdentity: { spanId?: string; parentSpanId?: string },
   finalized: boolean
@@ -574,6 +580,7 @@ function registerSubagentToolCall(
       id: toolCallId,
       name: toolName,
       status: 'pending',
+      agentId,
       params: args,
       startTime: Date.now(),
     }
@@ -594,6 +601,7 @@ function registerSubagentToolCall(
   const subagentToolCalls = context.subAgentToolCalls[parentToolCallId]
   const existingSubagentToolCall = subagentToolCalls.find((tc) => tc.id === toolCallId)
   if (existingSubagentToolCall) {
+    existingSubagentToolCall.agentId ??= agentId
     if (!rebindResolvedIntegrationCall(existingSubagentToolCall, toolName, args)) {
       updateToolCallFromFrame(existingSubagentToolCall, toolName, args, finalized)
     }
@@ -609,6 +617,7 @@ function registerMainToolCall(
   toolName: string,
   args: Record<string, unknown> | undefined,
   existing: ToolCallState | undefined,
+  agentId: string,
   ui: { title?: string; phaseLabel?: string; hidden?: boolean },
   finalized: boolean
 ): void {
@@ -633,6 +642,7 @@ function registerMainToolCall(
       id: toolCallId,
       name: toolName,
       status: 'pending',
+      agentId,
       params: args,
       startTime: Date.now(),
     }

apps/sim/lib/copilot/request/metrics.test.ts

@@ -0,0 +1,41 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+const { toolCallsAdd, toolDurationRecord } = vi.hoisted(() => ({
+  toolCallsAdd: vi.fn(),
+  toolDurationRecord: vi.fn(),
+}))
+
+vi.mock('@opentelemetry/api', () => ({
+  metrics: {
+    getMeter: vi.fn(() => ({
+      createCounter: vi.fn(() => ({ add: toolCallsAdd })),
+      createHistogram: vi.fn((name: string) => ({
+        record: name === 'copilot.tool.duration' ? toolDurationRecord : vi.fn(),
+      })),
+    })),
+  },
+}))
+
+import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
+import { recordSimToolMetric } from '@/lib/copilot/request/metrics'
+
+describe('recordSimToolMetric', () => {
+  it('attributes call counts to the agent without adding it to duration', () => {
+    recordSimToolMetric('read', 'workflow', 'success', 125)
+
+    const baseAttributes = {
+      [TraceAttr.ToolName]: 'read',
+      [TraceAttr.ToolExecutor]: 'sim',
+      [TraceAttr.ToolOutcome]: 'success',
+    }
+    expect(toolCallsAdd).toHaveBeenCalledWith(1, {
+      ...baseAttributes,
+      [TraceAttr.GenAiAgentName]: 'workflow',
+    })
+    expect(toolDurationRecord).toHaveBeenCalledWith(125, baseAttributes)
+  })
+})

apps/sim/lib/copilot/request/metrics.ts

@@ -71,15 +71,23 @@ function cappedToolName(name: string): string {
 // recordSimToolMetric emits copilot.tool.calls (+1) and copilot.tool.duration
 // for one server-side Sim tool dispatch (executor=sim). outcome is the bounded
 // tool outcome (success/error/…). Pure telemetry.
-export function recordSimToolMetric(name: string, outcome: string, durationMs: number): void {
+export function recordSimToolMetric(
+  name: string,
+  agentId: string,
+  outcome: string,
+  durationMs: number
+): void {
   const { toolDuration, toolCalls } = instruments()
-  const attrs = {
+  const baseAttrs = {
     [TraceAttr.ToolName]: cappedToolName(name),
     [TraceAttr.ToolExecutor]: 'sim',
     [TraceAttr.ToolOutcome]: outcome,
   }
-  toolCalls.add(1, attrs)
-  if (durationMs >= 0) toolDuration.record(durationMs, attrs)
+  toolCalls.add(1, {
+    ...baseAttrs,
+    [TraceAttr.GenAiAgentName]: agentId,
+  })
+  if (durationMs >= 0) toolDuration.record(durationMs, baseAttrs)
 }
 
 // recordVfsMaterialize records VFS materialization time. Call once per phase

apps/sim/lib/copilot/request/tools/executor.test.ts

@@ -1,13 +1,33 @@
 import '@sim/testing/mocks/executor'
 
-import { describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { recordSimToolMetric, setAttribute } = vi.hoisted(() => ({
+  recordSimToolMetric: vi.fn(),
+  setAttribute: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/metrics', () => ({
+  recordSimToolMetric,
+}))
+
+vi.mock('@/lib/copilot/request/otel', () => ({
+  withCopilotToolSpan: (
+    _input: unknown,
+    fn: (span: { setAttribute: typeof setAttribute }) => Promise<unknown>
+  ) => fn({ setAttribute }),
+}))
+
 import { TOOL_WATCHDOG_DEFAULT_MS, TOOL_WATCHDOG_LONG_RUNNING_MS } from '@/lib/copilot/constants'
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
 import {
   buildToolExecutionContext,
+  executeToolAndReport,
   pendingToolWaitBudgetMs,
   toolWatchdogTimeoutMs,
 } from '@/lib/copilot/request/tools/executor'
-import type { ExecutionContext } from '@/lib/copilot/request/types'
+import type { ExecutionContext, ToolCallState } from '@/lib/copilot/request/types'
 
 describe('toolWatchdogTimeoutMs', () => {
   it('gives request-scoped MCP tools the long-running watchdog', () => {
@@ -58,3 +78,59 @@ describe('buildToolExecutionContext', () => {
     })
   })
 })
+
+describe('executeToolAndReport metrics', () => {
+  const executionContext: ExecutionContext = {
+    userId: 'user-1',
+    workflowId: 'workflow-1',
+  }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('forwards the stored agent on normal completion', async () => {
+    const toolCall: ToolCallState = {
+      id: 'call-1',
+      name: 'read',
+      status: MothershipStreamV1ToolOutcome.success,
+      result: { success: true, output: 'done' },
+      agentId: 'workflow',
+      endTime: Date.now(),
+    }
+    const context = createStreamingContext({
+      toolCalls: new Map([[toolCall.id, toolCall]]),
+    })
+
+    await executeToolAndReport(toolCall.id, context, executionContext)
+
+    expect(recordSimToolMetric).toHaveBeenCalledWith(
+      'read',
+      'workflow',
+      MothershipStreamV1ToolOutcome.success,
+      expect.any(Number)
+    )
+  })
+
+  it('falls back to main when forwarding an unexpected throw', async () => {
+    const toolCall: ToolCallState = {
+      id: 'call-2',
+      name: 'read',
+      status: MothershipStreamV1ToolOutcome.error,
+      endTime: Date.now(),
+    }
+    const context = createStreamingContext({
+      toolCalls: new Map([[toolCall.id, toolCall]]),
+    })
+
+    await expect(executeToolAndReport(toolCall.id, context, executionContext)).rejects.toThrow(
+      'missing a canonical error'
+    )
+    expect(recordSimToolMetric).toHaveBeenCalledWith(
+      'read',
+      'main',
+      MothershipStreamV1ToolOutcome.error,
+      expect.any(Number)
+    )
+  })
+})

apps/sim/lib/copilot/request/tools/executor.ts

@@ -428,7 +428,12 @@ export async function executeToolAndReport(
         }
         // Durable Grafana signal for "which Sim tool is slowest" (executor=sim);
         // pairs with the Go executor-boundary metric (U15) as one series set.
-        recordSimToolMetric(toolCall.name, completion.status, durationMs)
+        recordSimToolMetric(
+          toolCall.name,
+          toolCall.agentId ?? 'main',
+          completion.status,
+          durationMs
+        )
         return completion
       } catch (err) {
         // executeToolAndReportInner threw (infra/unexpected error, not a normal
@@ -437,7 +442,12 @@ export async function executeToolAndReport(
         const durationMs = Date.now() - startedAt
         otelSpan.setAttribute(TraceAttr.ToolOutcome, 'error')
         otelSpan.setAttribute(TraceAttr.ToolDurationMs, durationMs)
-        recordSimToolMetric(toolCall.name, 'error', durationMs)
+        recordSimToolMetric(
+          toolCall.name,
+          toolCall.agentId ?? 'main',
+          MothershipStreamV1ToolOutcome.error,
+          durationMs
+        )
         throw err
       }
     }

apps/sim/lib/copilot/request/types.ts

@@ -25,6 +25,8 @@ export interface ToolCallState {
   id: string
   name: string
   status: ToolCallStatus
+  /** Bounded registry ID of the agent that invoked this tool. */
+  agentId?: string
   displayTitle?: string
   /** Model-authored activity text for a gateway-resolved integration call. */
   integrationDescription?: string