@morscherlab/mint-sdk 1.1.24 → 1.2.0-beta.1

package/src/composables/useEventStream.ts

@@ -0,0 +1,314 @@
+import {
+  getCurrentInstance,
+  getCurrentScope,
+  onMounted,
+  onScopeDispose,
+  ref,
+  shallowRef,
+  type Ref,
+} from 'vue'
+
+export type EventStreamTransport = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>
+
+export interface EventStreamMessage<TData = string> {
+  event: string
+  data: TData
+  id?: string
+  retry?: number
+  raw: string
+}
+
+export interface EventStreamOptions<TData = string> {
+  transport?: EventStreamTransport
+  headers?: HeadersInit
+  credentials?: RequestCredentials
+  immediate?: boolean
+  reconnect?: boolean
+  reconnectDelayMs?: number
+  parseJson?: boolean
+  shouldReconnect?: (cause?: unknown) => boolean
+  onOpen?: () => void
+  onMessage?: (message: EventStreamMessage<TData>) => void
+  onError?: (cause: unknown) => void
+  onClose?: (cause?: unknown) => void
+  errorLabel?: string
+}
+
+export interface UseEventStreamReturn<TData = string> {
+  isConnected: Ref<boolean>
+  isConnecting: Ref<boolean>
+  error: Ref<string | null>
+  lastMessage: Ref<EventStreamMessage<TData> | null>
+  lastEventId: Ref<string | null>
+  start: () => void
+  stop: () => void
+}
+
+interface ParsedEventStreamBlock<TData> {
+  message?: EventStreamMessage<TData>
+  id?: string
+  retry?: number
+}
+
+class EventStreamResponseError extends Error {
+  constructor(readonly response: Response, label: string) {
+    super(`${label} failed with HTTP ${response.status}`)
+    this.name = 'EventStreamResponseError'
+  }
+}
+
+/** Parse one complete SSE block without owning connection policy. */
+export function parseEventStreamBlock<TData>(
+  block: string,
+  parseJson: boolean,
+): ParsedEventStreamBlock<TData> | null {
+  let event = 'message'
+  let id: string | undefined
+  let retry: number | undefined
+  const dataLines: string[] = []
+
+  for (const line of block.split(/\r\n|\r|\n/)) {
+    if (!line || line.startsWith(':')) continue
+    const separator = line.indexOf(':')
+    const field = separator === -1 ? line : line.slice(0, separator)
+    const value = separator === -1
+      ? ''
+      : line.slice(separator + 1).replace(/^ /, '')
+
+    if (field === 'event') event = value || 'message'
+    if (field === 'data') dataLines.push(value)
+    if (field === 'id' && !value.includes('\0')) id = value
+    if (field === 'retry' && /^\d+$/.test(value)) retry = Number(value)
+  }
+
+  if (!dataLines.length && id === undefined && retry === undefined) return null
+  const data = dataLines.join('\n')
+  return {
+    message: dataLines.length
+      ? {
+          event,
+          data: (parseJson && data ? JSON.parse(data) : data) as TData,
+          id,
+          retry,
+          raw: block,
+        }
+      : undefined,
+    id,
+    retry,
+  }
+}
+
+/** Shared fetch-based SSE lifecycle with cancellation and reconnect safety. */
+export function useEventStream<TData = string>(
+  url: string | (() => string),
+  options: EventStreamOptions<TData> = {},
+): UseEventStreamReturn<TData> {
+  const isConnected = ref(false)
+  const isConnecting = ref(false)
+  const error = ref<string | null>(null)
+  const lastMessage = shallowRef<EventStreamMessage<TData> | null>(null)
+  const lastEventId = ref<string | null>(null)
+  let controller: AbortController | null = null
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null
+  let reconnectDelayMs = options.reconnectDelayMs ?? 2_000
+  let stopped = true
+  let generation = 0
+
+  function clearReconnectTimer(): void {
+    if (reconnectTimer === null) return
+    clearTimeout(reconnectTimer)
+    reconnectTimer = null
+  }
+
+  function ownsConnection(
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): boolean {
+    return !stopped
+      && generation === connectionGeneration
+      && controller === connectionController
+  }
+
+  function scheduleReconnect(connectionGeneration: number, cause?: unknown): void {
+    if (stopped || generation !== connectionGeneration) return
+    if (options.reconnect === false || options.shouldReconnect?.(cause) === false) {
+      stopped = true
+      return
+    }
+    clearReconnectTimer()
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null
+      if (stopped || generation !== connectionGeneration) return
+      void connect(connectionGeneration)
+    }, reconnectDelayMs)
+  }
+
+  function dispatchBlock(
+    block: string,
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): void {
+    const parsed = parseEventStreamBlock<TData>(block, options.parseJson ?? false)
+    if (!parsed || !ownsConnection(connectionGeneration, connectionController)) return
+    if (parsed.id !== undefined) {
+      lastEventId.value = parsed.id
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+    }
+    if (parsed.retry !== undefined) reconnectDelayMs = parsed.retry
+    const message = parsed.message
+    if (!message || !ownsConnection(connectionGeneration, connectionController)) return
+    lastMessage.value = message
+    if (!ownsConnection(connectionGeneration, connectionController)) return
+    options.onMessage?.(message)
+  }
+
+  async function consume(
+    body: ReadableStream<Uint8Array>,
+    connectionGeneration: number,
+    connectionController: AbortController,
+  ): Promise<void> {
+    const connectionReader = body.getReader()
+    reader = connectionReader
+    const decoder = new TextDecoder()
+    let buffer = ''
+    try {
+      for (;;) {
+        const { value, done } = await connectionReader.read()
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        buffer += decoder.decode(value, { stream: !done })
+
+        let boundary = /(?:\r\n|\r|\n){2}/.exec(buffer)
+        while (boundary?.index !== undefined) {
+          const block = buffer.slice(0, boundary.index)
+          buffer = buffer.slice(boundary.index + boundary[0].length)
+          dispatchBlock(block, connectionGeneration, connectionController)
+          if (!ownsConnection(connectionGeneration, connectionController)) return
+          boundary = /(?:\r\n|\r|\n){2}/.exec(buffer)
+        }
+
+        if (!done) continue
+        if (buffer) dispatchBlock(buffer, connectionGeneration, connectionController)
+        return
+      }
+    } finally {
+      if (reader === connectionReader) reader = null
+      connectionReader.releaseLock()
+    }
+  }
+
+  async function connect(connectionGeneration: number): Promise<void> {
+    if (stopped || generation !== connectionGeneration) return
+    controller?.abort()
+    const connectionController = new AbortController()
+    controller = connectionController
+    isConnecting.value = true
+    if (!ownsConnection(connectionGeneration, connectionController)) return
+    error.value = null
+    if (!ownsConnection(connectionGeneration, connectionController)) return
+
+    let cause: unknown
+    try {
+      const headers = new Headers(options.headers)
+      headers.set('Accept', 'text/event-stream')
+      if (lastEventId.value && !headers.has('Last-Event-ID')) {
+        headers.set('Last-Event-ID', lastEventId.value)
+      }
+      const transport = options.transport ?? globalThis.fetch?.bind(globalThis)
+      if (!transport) throw new Error('[MINT SDK] fetch is required for event streams.')
+      const response = await transport(typeof url === 'function' ? url() : url, {
+        method: 'GET',
+        headers,
+        credentials: options.credentials ?? 'same-origin',
+        signal: connectionController.signal,
+      })
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      if (!response.ok) {
+        throw new EventStreamResponseError(response, options.errorLabel ?? 'Event stream')
+      }
+      if (!response.body) {
+        throw new Error(`${options.errorLabel ?? 'Event stream'} response did not include a readable body.`)
+      }
+
+      isConnected.value = true
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      isConnecting.value = false
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      options.onOpen?.()
+      if (!ownsConnection(connectionGeneration, connectionController)) return
+      await consume(response.body, connectionGeneration, connectionController)
+    } catch (errorCause) {
+      cause = errorCause
+      if (
+        ownsConnection(connectionGeneration, connectionController)
+        && !isAbortError(errorCause)
+      ) {
+        error.value = errorCause instanceof Error
+          ? errorCause.message
+          : `${options.errorLabel ?? 'Event stream'} failed`
+        if (ownsConnection(connectionGeneration, connectionController)) {
+          options.onError?.(errorCause)
+        }
+      }
+    } finally {
+      if (ownsConnection(connectionGeneration, connectionController)) {
+        isConnecting.value = false
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        isConnected.value = false
+        if (!ownsConnection(connectionGeneration, connectionController)) return
+        controller = null
+        options.onClose?.(cause)
+        if (!stopped && generation === connectionGeneration) {
+          scheduleReconnect(connectionGeneration, cause)
+        }
+      }
+    }
+  }
+
+  function start(): void {
+    if (!stopped) return
+    stopped = false
+    clearReconnectTimer()
+    generation += 1
+    void connect(generation)
+  }
+
+  function stop(): void {
+    if (stopped) return
+    stopped = true
+    generation += 1
+    clearReconnectTimer()
+    controller?.abort()
+    controller = null
+    if (reader) void reader.cancel().catch(() => undefined)
+    reader = null
+    isConnecting.value = false
+    isConnected.value = false
+  }
+
+  const currentInstance = getCurrentInstance()
+  if (currentInstance && options.immediate !== false && typeof window === 'undefined') {
+    onMounted(start)
+  }
+  if (getCurrentScope()) onScopeDispose(stop)
+  if (options.immediate !== false && (typeof window !== 'undefined' || !currentInstance)) {
+    start()
+  }
+
+  return {
+    isConnected,
+    isConnecting,
+    error,
+    lastMessage,
+    lastEventId,
+    start,
+    stop,
+  }
+}
+
+function isAbortError(cause: unknown): boolean {
+  return cause instanceof DOMException && cause.name === 'AbortError'
+}

package/src/composables/useGeneratedAnalysis.ts

@@ -8,10 +8,8 @@ import {
   type ShallowRef,
 } from 'vue'
 
-import type {
-  JobsStatusTrayAdapter,
-  PluginJobCenterSource,
-} from './useJobsStatusTray'
+import type { PluginJobCenterSource } from './useJobsStatusTray'
+import { useEventStream, type EventStreamMessage } from './useEventStream'
 import { normalizeJobState } from '../jobs'
 import type {
   GeneratedAnalysisJob,
@@ -104,8 +102,6 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
   pause: () => void
   resume: () => void
   dispose: () => void
-  /** @deprecated Pass the runtime itself to SDK job UI as its source. */
-  jobsAdapter: JobsStatusTrayAdapter
 }
 
 export type UseGeneratedAnalysisReturn = UsePluginJobsReturn
@@ -125,6 +121,10 @@ interface PluginJobWaiter {
   abort?: () => void
 }
 
+type PluginJobStreamData = GeneratedAnalysisJobInput | {
+  jobs: GeneratedAnalysisJobInput[]
+}
+
 class GeneratedAnalysisRequestError extends Error {
   constructor(
     readonly status: number,
@@ -200,10 +200,6 @@ function createPluginJobs(
   const error = shallowRef<string | null>(null)
   const status = shallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>('idle')
   let pollTimer: ReturnType<typeof setTimeout> | undefined
-  let streamReconnectTimer: ReturnType<typeof setTimeout> | undefined
-  let streamController: AbortController | undefined
-  let streamConnected = false
-  let streamConnecting = false
   let disposed = false
   let paused = false
   let initialized = false
@@ -217,6 +213,17 @@ function createPluginJobs(
   const resultRetryAttempts = new Map<string, number>()
   const resultRetryTimers = new Map<string, ReturnType<typeof setTimeout>>()
   const downloadRefreshTimers = new Map<string, ReturnType<typeof setTimeout>>()
+  const jobStream = useEventStream<PluginJobStreamData>(`${baseUrl}/jobs/events`, {
+    transport,
+    immediate: false,
+    reconnectDelayMs: streamReconnectDelay,
+    parseJson: true,
+    errorLabel: 'Job stream',
+    onOpen: clearPoll,
+    onMessage: applyJobStreamMessage,
+    onError: schedulePollForActiveJobs,
+    onClose: schedulePollForActiveJobs,
+  })
 
   const latestResult = computed<GeneratedAnalysisResult | null>(() => {
     const job = currentCompletedJob()
@@ -242,7 +249,7 @@ function createPluginJobs(
       if (disposed) return
       initialized = true
       status.value = paused ? 'paused' : 'ready'
-      if (streamEnabled && !paused) void connectJobStream()
+      if (streamEnabled && !paused) jobStream.start()
     })().catch((cause: unknown) => {
       if (!disposed) {
         error.value = errorMessage(cause, 'Failed to initialize generated analysis')
@@ -303,7 +310,7 @@ function createPluginJobs(
         )
       }
       const job = upsertJob(jobInput, definitionId)
-      if (!streamConnected) schedulePoll()
+      if (!jobStream.isConnected.value) schedulePoll()
       return job
     } catch (cause) {
       error.value = errorMessage(cause, 'Failed to submit analysis')
@@ -466,7 +473,7 @@ function createPluginJobs(
         }
         replaceJobs(payload.jobs)
         error.value = null
-        if (!paused && !streamConnected && jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) {
+        if (!paused && !jobStream.isConnected.value && jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) {
           schedulePoll()
         }
         return jobs.value
@@ -540,12 +547,12 @@ function createPluginJobs(
       waiting.add(waiter)
       jobWaiters.set(jobId, waiting)
       if (!paused) {
-        if (streamEnabled) void connectJobStream()
-        if (!streamConnected) schedulePoll()
+        if (streamEnabled) jobStream.start()
+        if (!jobStream.isConnected.value) schedulePoll()
       }
       void getJob(jobId, { signal: options.signal }).catch((cause: unknown) => {
         if (current && isRetryableJobLookupError(cause)) {
-          if (!streamConnected) schedulePoll()
+          if (!jobStream.isConnected.value) schedulePoll()
           return
         }
         removeJobWaiter(jobId, waiter)
@@ -895,7 +902,7 @@ function createPluginJobs(
   }
 
   function schedulePoll(): void {
-    if (disposed || paused || streamConnected || pollTimer !== undefined) return
+    if (disposed || paused || jobStream.isConnected.value || pollTimer !== undefined) return
     pollTimer = setTimeout(async () => {
       pollTimer = undefined
       if (disposed) return
@@ -908,85 +915,26 @@ function createPluginJobs(
     }, pollInterval)
   }
 
-  async function connectJobStream(): Promise<void> {
-    if (disposed || paused || streamConnecting || streamConnected) return
-    streamConnecting = true
-    streamController = new AbortController()
-    try {
-      const response = await transport(`${baseUrl}/jobs/events`, {
-        method: 'GET',
-        headers: { Accept: 'text/event-stream' },
-        signal: streamController.signal,
-      })
-      if (!response.ok) throw new Error(`Job stream failed (${response.status})`)
-      if (!response.body) throw new Error('Job stream response has no readable body')
-      streamConnected = true
-      if (pollTimer !== undefined) {
-        clearTimeout(pollTimer)
-        pollTimer = undefined
-      }
-      await consumeJobStream(response.body)
-    } catch (cause) {
-      if (!isAbortError(cause) && !disposed) {
-        if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
-      }
-    } finally {
-      streamConnected = false
-      streamConnecting = false
-      streamController = undefined
-      if (!disposed && !paused) scheduleStreamReconnect()
-    }
+  function clearPoll(): void {
+    if (pollTimer === undefined) return
+    clearTimeout(pollTimer)
+    pollTimer = undefined
   }
 
-  async function consumeJobStream(body: ReadableStream<Uint8Array>): Promise<void> {
-    const reader = body.getReader()
-    const decoder = new TextDecoder()
-    let buffer = ''
-    try {
-      while (!disposed) {
-        const { done, value } = await reader.read()
-        buffer += decoder.decode(value, { stream: !done })
-        const blocks = buffer.split(/\r?\n\r?\n/)
-        buffer = blocks.pop() ?? ''
-        for (const block of blocks) applyJobStreamEvent(block)
-        if (done) {
-          if (buffer.trim()) applyJobStreamEvent(buffer)
-          return
-        }
-      }
-    } finally {
-      reader.releaseLock()
-    }
+  function schedulePollForActiveJobs(): void {
+    if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
   }
 
-  function applyJobStreamEvent(block: string): void {
-    let event = 'message'
-    const data: string[] = []
-    for (const line of block.split(/\r?\n/)) {
-      if (!line || line.startsWith(':')) continue
-      if (line.startsWith('event:')) event = line.slice('event:'.length).trim()
-      if (line.startsWith('data:')) data.push(line.slice('data:'.length).trimStart())
-    }
-    if (!data.length) return
-    const payload = JSON.parse(data.join('\n')) as (
-      GeneratedAnalysisJobInput | { jobs: GeneratedAnalysisJobInput[] }
-    )
-    if (event === 'snapshot' && 'jobs' in payload) {
+  function applyJobStreamMessage(message: EventStreamMessage<PluginJobStreamData>): void {
+    if (message.event === 'snapshot' && 'jobs' in message.data) {
+      const payload = message.data
       replaceJobs(payload.jobs)
-    } else if (event === 'job' || event === 'terminal') {
-      upsertJob(payload as GeneratedAnalysisJobInput)
+    } else if (message.event === 'job' || message.event === 'terminal') {
+      upsertJob(message.data as GeneratedAnalysisJobInput)
     }
     error.value = null
   }
 
-  function scheduleStreamReconnect(): void {
-    if (disposed || paused || streamReconnectTimer !== undefined) return
-    streamReconnectTimer = setTimeout(() => {
-      streamReconnectTimer = undefined
-      void connectJobStream()
-    }, streamReconnectDelay)
-  }
-
   async function cancelJob(job: GeneratedAnalysisJob | string): Promise<GeneratedAnalysisJob> {
     const jobId = typeof job === 'string' ? job : job.job_id
     const revision = beginJobOperation(jobId)
@@ -1024,25 +972,16 @@ function createPluginJobs(
     return payload.deleted
   }
 
-  const jobsAdapter: JobsStatusTrayAdapter = {
-    listJobs: async () => ({ jobs: await refreshJobs() }),
-    cancelJob: async job => cancelJob(job as GeneratedAnalysisJob),
-    deleteJob: async job => deleteJob(job as GeneratedAnalysisJob),
-    clearFinishedJobs: async () => clearFinishedJobs(),
-  }
   function pause(): void {
     if (disposed || paused) return
     paused = true
     status.value = 'paused'
-    if (pollTimer !== undefined) clearTimeout(pollTimer)
-    if (streamReconnectTimer !== undefined) clearTimeout(streamReconnectTimer)
-    pollTimer = undefined
-    streamReconnectTimer = undefined
+    clearPoll()
     for (const jobId of resultRetryTimers.keys()) clearResultRetry(jobId)
     for (const jobId of downloadRefreshTimers.keys()) {
       clearManagedDownloadRefresh(jobId)
     }
-    streamController?.abort()
+    jobStream.stop()
   }
 
   function resume(): void {
@@ -1053,7 +992,7 @@ function createPluginJobs(
     for (const [jobId, result] of Object.entries(resultCache.value)) {
       scheduleManagedDownloadRefresh(jobId, managedDownloadRefreshDelay(result))
     }
-    if (streamEnabled) void connectJobStream()
+    if (streamEnabled) jobStream.start()
     else if (jobs.value.some(job => ACTIVE_STATUSES.has(job.status))) schedulePoll()
   }
 
@@ -1062,10 +1001,7 @@ function createPluginJobs(
     disposed = true
     paused = true
     status.value = 'disposed'
-    if (pollTimer !== undefined) clearTimeout(pollTimer)
-    if (streamReconnectTimer !== undefined) clearTimeout(streamReconnectTimer)
-    pollTimer = undefined
-    streamReconnectTimer = undefined
+    clearPoll()
     for (const timer of resultRetryTimers.values()) clearTimeout(timer)
     resultRetryTimers.clear()
     resultRetryAttempts.clear()
@@ -1075,7 +1011,7 @@ function createPluginJobs(
     for (const jobId of jobWaiters.keys()) rejectJobWaiters(jobId, cause)
     jobRevisions.clear()
     pendingJobOperations.clear()
-    streamController?.abort()
+    jobStream.stop()
   }
 
   async function request<T>(path: string, init: RequestInit): Promise<T> {
@@ -1129,7 +1065,6 @@ function createPluginJobs(
     pause,
     resume,
     dispose,
-    jobsAdapter,
   }
 }
 
@@ -1229,10 +1164,6 @@ function createGeneratedSessionStorage(candidate?: Storage): GeneratedSessionSto
   }
 }
 
-function isAbortError(error: unknown): boolean {
-  return error instanceof DOMException && error.name === 'AbortError'
-}
-
 function isSessionNotFoundError(error: unknown): boolean {
   return error instanceof GeneratedAnalysisRequestError
     && error.status === 404