@bagelink/sdk 1.7.101 → 1.7.104

package/src/openAPITools/streamClient.ts

@@ -0,0 +1,247 @@
+/* eslint-disable ts/no-unnecessary-condition */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable ts/strict-boolean-expressions */
+/* eslint-disable ts/use-unknown-in-catch-callback-variable */
+/**
+ * SSE (Server-Sent Events) Client Utilities
+ * Provides utilities for consuming Server-Sent Events streams
+ */
+
+import type { StreamEventMap } from './StreamController'
+import { StreamController } from './StreamController'
+
+export { type SSEEvent, StreamController, type StreamEventMap } from './StreamController'
+
+export interface SSEStreamOptions {
+	/** Additional headers to send with the request */
+	headers?: Record<string, string>
+	/** Whether to include credentials (cookies) with the request */
+	withCredentials?: boolean
+}
+
+/**
+ * Creates an SSE stream consumer with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStream(url)
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ *
+ * // Close when needed
+ * stream.close()
+ * ```
+ */
+export function createSSEStream<TEventMap extends StreamEventMap = StreamEventMap>(
+	url: string,
+	options: SSEStreamOptions = {}
+): StreamController<TEventMap> {
+	const { headers = {}, withCredentials = true } = options
+
+	return new StreamController((onEvent, onError, onComplete) => {
+		const controller = new AbortController()
+		const { signal } = controller
+
+		// Start the fetch request
+		fetch(url, {
+			method: 'GET',
+			headers: {
+				Accept: 'text/event-stream',
+				...headers,
+			},
+			credentials: withCredentials ? 'include' : 'same-origin',
+			signal,
+		})
+			.then(async (response) => {
+				if (!response.ok) {
+					throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+				}
+
+				if (!response.body) {
+					throw new Error('Response body is null')
+				}
+
+				const reader = response.body.getReader()
+				const decoder = new TextDecoder()
+				let buffer = ''
+
+				try {
+					while (true) {
+						const { done, value } = await reader.read()
+
+						if (done) {
+							onComplete()
+							break
+						}
+
+						// Decode the chunk and add to buffer
+						buffer += decoder.decode(value, { stream: true })
+
+						// Process complete events in the buffer
+						const lines = buffer.split('\n')
+						buffer = lines.pop() || '' // Keep incomplete line in buffer
+
+						let eventType = ''
+						let eventData = ''
+
+						for (const line of lines) {
+							if (line.startsWith('event:')) {
+								eventType = line.slice(6).trim()
+							} else if (line.startsWith('data:')) {
+								eventData = line.slice(5).trim()
+							} else if (line === '' && eventData) {
+								// Empty line indicates end of event
+								try {
+									const parsedData = JSON.parse(eventData)
+									onEvent({
+										type: eventType || 'message',
+										data: parsedData,
+										raw: eventData,
+									})
+								} catch {
+									// If not JSON, pass as string
+									onEvent({
+										type: eventType || 'message',
+										data: eventData,
+										raw: eventData,
+									})
+								}
+								eventType = ''
+								eventData = ''
+							}
+						}
+					}
+				} catch (error) {
+					if (error instanceof Error && error.name !== 'AbortError') {
+						onError(error)
+					}
+				}
+			})
+			.catch((error) => {
+				if (error.name !== 'AbortError') {
+					onError(error)
+				}
+			})
+
+		// Return cleanup function
+		return () => { controller.abort() }
+	})
+}
+
+/**
+ * Creates an SSE stream consumer for POST requests with elegant event-based API
+ * @param url - The SSE endpoint URL
+ * @param body - Request body
+ * @param options - Stream options
+ * @returns StreamController for chainable event handling
+ *
+ * @example
+ * ```typescript
+ * const stream = createSSEStreamPost(url, { message: 'Hello' })
+ *   .on('token', data => console.log(data))
+ *   .on('done', () => console.log('Complete!'))
+ *   .on('error', err => console.error(err))
+ * ```
+ */
+export function createSSEStreamPost<TEventMap extends StreamEventMap = StreamEventMap, TBody = any>(
+	url: string,
+	body: TBody,
+	options: SSEStreamOptions = {}
+): StreamController<TEventMap> {
+	const { headers = {}, withCredentials = true } = options
+
+	return new StreamController((onEvent, onError, onComplete) => {
+		const controller = new AbortController()
+		const { signal } = controller
+
+		// Start the fetch request
+		fetch(url, {
+			method: 'POST',
+			headers: {
+				'Accept': 'text/event-stream',
+				'Content-Type': 'application/json',
+				...headers,
+			},
+			credentials: withCredentials ? 'include' : 'same-origin',
+			body: JSON.stringify(body),
+			signal,
+		})
+			.then(async (response) => {
+				if (!response.ok) {
+					throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+				}
+
+				if (!response.body) {
+					throw new Error('Response body is null')
+				}
+
+				const reader = response.body.getReader()
+				const decoder = new TextDecoder()
+				let buffer = ''
+
+				try {
+					while (true) {
+						const { done, value } = await reader.read()
+
+						if (done) {
+							onComplete()
+							break
+						}
+
+						// Decode the chunk and add to buffer
+						buffer += decoder.decode(value, { stream: true })
+
+						// Process complete events in the buffer
+						const lines = buffer.split('\n')
+						buffer = lines.pop() || '' // Keep incomplete line in buffer
+
+						let eventType = ''
+						let eventData = ''
+
+						for (const line of lines) {
+							if (line.startsWith('event:')) {
+								eventType = line.slice(6).trim()
+							} else if (line.startsWith('data:')) {
+								eventData = line.slice(5).trim()
+							} else if (line === '' && eventData) {
+								// Empty line indicates end of event
+								try {
+									const parsedData = JSON.parse(eventData)
+									onEvent({
+										type: eventType || 'message',
+										data: parsedData,
+										raw: eventData,
+									})
+								} catch {
+									// If not JSON, pass as string
+									onEvent({
+										type: eventType || 'message',
+										data: eventData,
+										raw: eventData,
+									})
+								}
+								eventType = ''
+								eventData = ''
+							}
+						}
+					}
+				} catch (error) {
+					if (error instanceof Error && error.name !== 'AbortError') {
+						onError(error)
+					}
+				}
+			})
+			.catch((error) => {
+				if (error.name !== 'AbortError') {
+					onError(error)
+				}
+			})
+
+		// Return cleanup function
+		return () => { controller.abort() }
+	})
+}

package/src/openAPITools/streamDetector.ts

@@ -0,0 +1,44 @@
+import type { OperationObject as OpenAPIOperation } from './types'
+
+/**
+ * Detects if an operation is an SSE (Server-Sent Events) stream endpoint
+ * @param operation - The OpenAPI operation object
+ * @returns Whether the operation is an SSE stream
+ */
+export function isSSEStream(operation: OpenAPIOperation): boolean {
+	const description = operation.description?.toLowerCase() || ''
+	const summary = operation.summary?.toLowerCase() || ''
+
+	// Check for SSE indicators in description or summary
+	const hasSSEKeywords
+		= description.includes('sse')
+			|| description.includes('server-sent events')
+			|| description.includes('event stream')
+			|| summary.includes('stream')
+
+	// Check for text/event-stream content type in responses
+	const responses = operation.responses || {}
+	const hasEventStreamContentType = Object.values(responses).some((response: any) => {
+		if ('content' in response) {
+			return 'text/event-stream' in (response.content || {})
+		}
+		return false
+	})
+
+	return hasSSEKeywords || hasEventStreamContentType
+}
+
+/**
+ * Extracts SSE event types from operation description
+ * @param operation - The OpenAPI operation object
+ * @returns Array of event types or undefined
+ */
+export function extractSSEEventTypes(operation: OpenAPIOperation): string[] | undefined {
+	const description = operation.description || ''
+
+	// Look for patterns like: type: "token", type: "done", etc.
+	const typeMatches = description.matchAll(/type:\s*"([^"]+)"/g)
+	const types = Array.from(typeMatches).map(match => match[1])
+
+	return types.length > 0 ? types : undefined
+}