Function start

apps/sim/lib/copilot/request/lifecycle/start.ts:159–395

(controller)

  return new ReadableStream({
    async start(controller) {
      publisher.attach(controller)

      // Re-enter the root OTel context — ALS doesn't survive the
      // Next handler → ReadableStream.start boundary.
      await otelContextApi.with(activeOtelRoot.context, async () => {
        const otelContext = activeOtelRoot.context
        let rootOutcome: CopilotLifecycleOutcome = RequestTraceV1Outcome.error
        let rootError: unknown
        // `cancelReason` must be declared OUTSIDE the outer `try` so
        // it remains in scope for the outer `finally` that calls
        // `activeOtelRoot.finish(rootOutcome, rootError, cancelReason)`.
        // `let` bindings declared inside a `try` block are NOT visible
        // in the paired `finally`; referencing one there raises a
        // TDZ ReferenceError, skipping `finish()`, leaving the root
        // span never-ended, and making Tempo see every child as an
        // orphan under a phantom parent. (Regression landed 2026-04-21.)
        let cancelReason: CopilotRequestCancelReasonValue | undefined
        try {
          const requestSpan = collector.startSpan('Sim Agent Request', 'request', {
            streamId,
            chatId,
            runId,
          })
          let outcome: CopilotLifecycleOutcome = RequestTraceV1Outcome.error
          let lifecycleResult:
            | {
                usage?: { prompt: number; completion: number }
                cost?: { input: number; output: number; total: number }
              }
            | undefined

          await Promise.all([resetBuffer(streamId), clearFilePreviewSessions(streamId)])

          if (chatId) {
            createRunSegment({
              id: runId,
              executionId,
              chatId,
              userId,
              workflowId: (requestPayload.workflowId as string | undefined) || null,
              workspaceId,
              streamId,
              model: (requestPayload.model as string | undefined) || null,
              provider: (requestPayload.provider as string | undefined) || null,
              requestContext: { requestId },
            }).catch((error) => {
              logger.warn(`[${requestId}] Failed to create copilot run segment`, {
                error: getErrorMessage(error),
              })
            })
          }

          const abortPoller = startAbortPoller(streamId, abortController, {
            requestId,
            chatId,
          })
          publisher.startKeepalive()