Method sendMessageStreaming

src/main/aiHandler.ts:278–330

(
    event: Electron.IpcMainInvokeEvent,
    request: AIRequest,
    eventChannel: string
  )

  }

  public async sendMessageStreaming(
    event: Electron.IpcMainInvokeEvent,
    request: AIRequest,
    eventChannel: string
  ): Promise<void> {
    const abortController = new AbortController()
    this.abortControllers.set(request.requestId, abortController)
    this.initRequestState(request.requestId, event, eventChannel)

    try {
      const modelConfig = this.getModelConfig(request.modelConfig)
      const apiMessages = await this.prepareApiMessages(request.messages, modelConfig)
      const response = await this.fetchStreamingResponse(
        request,
        apiMessages,
        modelConfig,
        abortController
      )

      if (!response.ok) {
        let errorDetail = ''
        try {
          const errorBody = await response.text()
          const parsed = JSON.parse(errorBody)
          errorDetail = parsed.error?.message || parsed.message || errorBody
        } catch {
          errorDetail = response.statusText
        }

        this.finalizeTerminalError(request.requestId, `HTTP ${response.status}: ${errorDetail}`)
        return
      }

      const reader = response.body?.getReader()
      if (!reader) {
        this.finalizeTerminalError(request.requestId, 'No response body reader available')
        return
      }

      const parser = this.createStreamParser(request.requestId)
      await this.processStreamResponse(request.requestId, reader, parser)
    } catch (error) {
      if (error instanceof Error && error.name === 'AbortError') {
        this.finalizeComplete(request.requestId)
        return
      }

      this.finalizeTerminalError(
        request.requestId,
        error instanceof Error ? error.message : 'Unknown error'
      )
    }
  }

  public async stopStreaming(requestId: string): Promise<void> {
    const abortController = this.abortControllers.get(requestId)