ai.libx.js 0.1.1

package/src/adapters/openai.ts

@@ -0,0 +1,129 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk, Message } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+interface OpenAIMessage {
+	role: string;
+	content: string;
+}
+
+interface OpenAIRequest {
+	model: string;
+	messages: OpenAIMessage[];
+	temperature?: number;
+	max_tokens?: number;
+	top_p?: number;
+	frequency_penalty?: number;
+	presence_penalty?: number;
+	stop?: string | string[];
+	stream?: boolean;
+}
+
+/**
+ * OpenAI API adapter
+ */
+export class OpenAIAdapter extends BaseAdapter {
+	get name(): string {
+		return 'openai';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.openai.com/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^openai\//, '');
+
+			const request: OpenAIRequest = {
+				model,
+				messages: this.transformMessages(options.messages),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.frequencyPenalty !== undefined) request.frequency_penalty = options.frequencyPenalty;
+			if (options.presencePenalty !== undefined) request.presence_penalty = options.presencePenalty;
+			if (options.stop !== undefined) request.stop = options.stop;
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private transformMessages(messages: Message[]): OpenAIMessage[] {
+		return messages.map((msg) => ({
+			role: msg.role,
+			content: msg.content,
+		}));
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+

package/src/adapters/openrouter.ts

@@ -0,0 +1,110 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+/**
+ * OpenRouter API adapter (uses OpenAI-compatible API)
+ */
+export class OpenRouterAdapter extends BaseAdapter {
+	get name(): string {
+		return 'openrouter';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://openrouter.ai/api/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^openrouter\//, '');
+
+			const request: any = {
+				model,
+				messages: options.messages.map((msg) => ({
+					role: msg.role,
+					content: msg.content,
+				})),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.frequencyPenalty !== undefined) request.frequency_penalty = options.frequencyPenalty;
+			if (options.presencePenalty !== undefined) request.presence_penalty = options.presencePenalty;
+			if (options.stop !== undefined) request.stop = options.stop;
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+						'HTTP-Referer': options.providerOptions?.httpReferer || 'https://ai.libx.js',
+						'X-Title': options.providerOptions?.xTitle || 'ai.libx.js',
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+

package/src/adapters/xai.ts

@@ -0,0 +1,106 @@
+import { BaseAdapter } from './base/BaseAdapter';
+import { ChatOptions, ChatResponse, StreamChunk } from '../types';
+import { parseSSEStream } from '../utils/stream';
+import { handleProviderError } from '../utils/errors';
+
+/**
+ * xAI (Grok) API adapter (uses OpenAI-compatible API)
+ */
+export class XAIAdapter extends BaseAdapter {
+	get name(): string {
+		return 'xai';
+	}
+
+	async chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>> {
+		try {
+			const apiKey = this.getApiKey(options);
+			const baseUrl = this.getBaseUrl('https://api.x.ai/v1');
+
+			// Strip provider prefix from model if present
+			const model = options.model.replace(/^xai\//, '');
+
+			const request: any = {
+				model,
+				messages: options.messages.map((msg) => ({
+					role: msg.role,
+					content: msg.content,
+				})),
+				stream: options.stream || false,
+			};
+
+			// Add optional parameters
+			if (options.temperature !== undefined) request.temperature = options.temperature;
+			if (options.maxTokens !== undefined) request.max_tokens = options.maxTokens;
+			if (options.topP !== undefined) request.top_p = options.topP;
+			if (options.stop !== undefined) request.stop = options.stop;
+
+			// Merge provider-specific options
+			if (options.providerOptions) {
+				Object.assign(request, options.providerOptions);
+			}
+
+			const response = await this.fetchWithErrorHandling(
+				`${baseUrl}/chat/completions`,
+				{
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'Authorization': `Bearer ${apiKey}`,
+					},
+					body: JSON.stringify(request),
+				},
+				this.name
+			);
+
+			if (options.stream) {
+				return this.handleStreamResponse(response, model);
+			}
+
+			return this.handleNonStreamResponse(await response.json(), model);
+		} catch (error) {
+			handleProviderError(error, this.name);
+		}
+	}
+
+	private handleNonStreamResponse(data: any, model: string): ChatResponse {
+		const choice = data.choices?.[0];
+		if (!choice) {
+			throw new Error('No choices in response');
+		}
+
+		return {
+			content: choice.message?.content || '',
+			finishReason: choice.finish_reason,
+			usage: data.usage ? {
+				promptTokens: data.usage.prompt_tokens,
+				completionTokens: data.usage.completion_tokens,
+				totalTokens: data.usage.total_tokens,
+			} : undefined,
+			model,
+			raw: data,
+		};
+	}
+
+	private async *handleStreamResponse(response: Response, model: string): AsyncIterable<StreamChunk> {
+		if (!response.body) {
+			throw new Error('No response body for streaming');
+		}
+
+		for await (const chunk of parseSSEStream(response.body)) {
+			const choice = chunk.choices?.[0];
+			if (!choice) continue;
+
+			const content = choice.delta?.content || '';
+			const finishReason = choice.finish_reason;
+
+			if (content || finishReason) {
+				yield {
+					content,
+					finishReason,
+					index: choice.index,
+				};
+			}
+		}
+	}
+}
+

package/src/index.ts

@@ -0,0 +1,66 @@
+// Main export: AIClient
+export { AIClient } from './AIClient';
+export type { AIClientConfig } from './AIClient';
+
+// Default export
+import { AIClient } from './AIClient';
+export default AIClient;
+
+// Export types
+export {
+    Message,
+    MessageRole,
+    ChatOptions,
+    ChatResponse,
+    StreamChunk,
+    ModelCapabilities,
+    ModelInfo,
+    ProviderConfig,
+} from './types';
+
+export { IProviderAdapter } from './types/provider';
+export { ChatStream } from './types/streaming';
+
+// Export model utilities
+export {
+    supportedModels,
+    getProviderFromModel,
+    getModelInfo,
+    listModels,
+    isModelSupported,
+} from './models';
+
+// Export model normalization utilities
+export {
+    normalizeModelName,
+    isReasoningModel,
+    supportsSystemMessages,
+    getReasoningModelAdjustments,
+} from './utils/model-normalization';
+
+// Export request logger
+export {
+    RequestLogger,
+    getRequestLogger,
+} from './utils/request-logger';
+
+export type {
+    RequestMetadata,
+    RequestTracker,
+    CompletedRequest,
+    ProviderStats,
+    LoggerStats,
+} from './utils/request-logger';
+
+// Export errors
+export {
+    AILibError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    ModelNotFoundError,
+    ProviderError,
+} from './utils/errors';
+
+// Note: Individual adapters are exported from './adapters' subpath
+// Usage: import { OpenAIAdapter } from 'ai.libx.js/adapters';

package/src/models.ts

@@ -0,0 +1,116 @@
+import { ModelInfo } from './types';
+
+// Import the supported models data
+export const supportedModels: Record<string, ModelInfo> = {
+	'openai/gpt-5': { displayName: 'GPT-5' },
+	'openai/gpt-5-mini': { displayName: 'GPT-5 mini' },
+	'openai/gpt-5-nano': { displayName: 'GPT-5 nano' },
+	'openai/gpt-5-chat-latest': { displayName: 'GPT-5 Chat' },
+	'openai/gpt-4.1': { displayName: 'GPT 4.1' },
+	'openai/gpt-4.1-mini': { displayName: 'GPT 4.1 mini' },
+	'openai/gpt-4.1-nano': { displayName: 'GPT 4.1 nano' },
+	'openai/gpt-4.5-preview': { displayName: 'gpt 4.5 preview' },
+	'openai/o3-mini': { displayName: 'gpt o3 mini', noSystem: true },
+	'openai/gpt-4o-audio-preview': { displayName: 'gpt-4o-audio-preview', enabled: false },
+	'openai/gpt-4o-mini-audio-preview': { displayName: 'gpt-4o-mini-audio-preview', enabled: false },
+	'openai/gpt-4o-mini-realtime-preview': { displayName: 'gpt-4o-mini-realtime-preview', noChat: true },
+	'openai/gpt-4o-realtime-preview': { displayName: 'gpt-4o-realtime-preview', noChat: true },
+	'openai/o1-preview': { displayName: 'o1-preview', noSystem: true },
+	'openai/o1-mini': { displayName: 'o1-mini', noSystem: true },
+	'openai/o1': { displayName: 'o1', noSystem: true, enabled: false },
+	'openai/chatgpt-4o-latest': { displayName: ' ChatGPT GPT-4o' },
+	'openai/gpt-4o-mini': { displayName: 'GPT-4o mini' },
+	'openai/gpt-4o': { displayName: ' GPT-4o' },
+	'openai/gpt-4o-2024-05-13': { displayName: ' GPT-4o (2024-05-13)' },
+	'openai/gpt-4-turbo': { displayName: 'GPT-4 Turbo with Vision' },
+	'openai/gpt-4-turbo-2024-04-09': { displayName: 'GPT-4 Turbo with Vision (2024-04-09)' },
+	'openai/gpt-4-turbo-preview': { displayName: 'GPT-4 Turbo (gpt-4-turbo-preview)' },
+	'openai/gpt-4-0125-preview': { displayName: 'GPT-4 25-01 (gpt-4-0125-preview)' },
+	'openai/gpt-4-1106-preview': { displayName: 'GPT-4 06-11 (gpt-4-1106-preview)' },
+	'openai/gpt-4-vision-preview': { displayName: 'GPT-4 Vision', enabled: false },
+	'openai/gpt-4-32k': { displayName: 'gpt-4-32k' },
+	'openai/gpt-4-0613': { displayName: 'gpt-4-0613' },
+	'openai/gpt-4-32k-0613': { displayName: 'gpt-4-32k-0613' },
+	'openai/gpt-4': { displayName: 'gpt-4' },
+	'openai/gpt-4-0314': { displayName: 'gpt-4-0314' },
+	'openai/gpt-3.5-turbo': { displayName: 'gpt-3.5-turbo' },
+	'openai/gpt-3.5-turbo-0125': { displayName: 'gpt-3.5-turbo-0125' },
+	'openai/gpt-3.5-turbo-1106': { displayName: 'gpt-3.5-turbo-1106' },
+	'openai/gpt-3.5-turbo-instruct': { displayName: 'gpt-3.5-turbo-instruct' },
+	'openai/gpt-3.5-turbo-16k': { displayName: 'gpt-3.5-turbo-16k' },
+	'openai/gpt-3.5-turbo-0613': { displayName: 'gpt-3.5-turbo-0613', enabled: false },
+	'openai/gpt-3.5-turbo-16k-0613': { displayName: 'gpt-3.5-turbo-16k-0613', enabled: false },
+	'openai/text-davinci-003': { displayName: 'text-davinci-003' },
+	'openai/text-davinci-002': { displayName: 'text-davinci-002' },
+	'google/models/gemini-2.5-flash': { displayName: 'Gemini 2.5 Flash', reasoning: true },
+	'google/models/gemini-2.5-flash-lite-preview-06-17': { displayName: 'Gemini 2.5 Flash-Lite Preview 06-17', reasoning: true },
+	'google/models/gemini-2.5-pro': { displayName: 'Gemini 2.5 Pro', reasoning: true },
+	'google/models/gemini-2.5-pro-exp-03-25': { displayName: 'Gemini 2.5 Pro Experimental 03-25', reasoning: true },
+	'google/models/gemini-2.0-flash': { displayName: 'Gemini 2.0 Flash' },
+	'google/models/gemini-2.0-flash-lite': { displayName: 'Gemini 2.0 Flash-Lite' },
+	'google/models/gemini-2.0-flash-preview-image-generation': { displayName: 'Gemini 2.0 Flash Preview Image Generation', responseModalities: ['Text', 'Image'] },
+	'google/models/gemini-2.0-pro-exp-02-05': { displayName: 'Gemini 2.0 Pro Experimental 02-05' },
+	'google/models/gemini-2.0-flash-thinking-exp-01-21': { displayName: 'Gemini 2.0 Flash Thinking Experimental 01-21' },
+	'google/models/gemini-2.0-flash-exp': { displayName: 'Gemini 2.0 Flash Experimental', responseModalities: ['Text', 'Image'] },
+	'google/models/gemini-2.0-flash-thinking-exp-1219': { displayName: 'Gemini 2.0 Flash Thinking Mode' },
+	'google/models/gemma-3n-e4b-it': { displayName: 'Gemma 3n E4B' },
+	'google/models/gemma-3n-e2b-it': { displayName: 'Gemma 3n E2B' },
+	'google/models/gemma-3-27b-it': { displayName: 'Gemma 3 27B' },
+	'google/models/learnlm-1.5-pro-experimental': { displayName: 'LearnLM 1.5 Pro Experimental' },
+	'google/models/gemini-exp-1206': { displayName: 'Gemini (exp-1206)' },
+	'google/models/gemini-1.5-flash-8b': { displayName: 'Gemini 1.5 Flash-8B' },
+	'google/models/gemini-1.5-pro-002': { displayName: 'Gemini 1.5 Pro 2' },
+	'google/models/gemini-1.5-flash-002': { displayName: 'Gemini 1.5 Flash 2' },
+	'google/models/gemini-1.5-flash-latest': { displayName: 'Gemini 1.5 Flash' },
+	'google/models/gemini-1.5-pro-latest': { displayName: 'Gemini 1.5 Pro' },
+	'google/models/gemini-1.0-pro-latest': { displayName: 'Gemini 1.0 Pro' },
+	'google/models/gemini-pro-vision': { displayName: 'Gemini 1.0 Pro Vision' },
+	'google/models/chat-bison-001': { displayName: 'PaLM 2 Chat (Legacy)' },
+	'anthropic/claude-opus-4-1': { displayName: 'Claude Opus 4.1', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-opus-4-0': { displayName: 'Claude Opus 4', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-sonnet-4-5': { displayName: 'Claude Sonnet 4.5', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-sonnet-4-0': { displayName: 'Claude Sonnet 4', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-7-sonnet-latest': { displayName: 'Claude 3.7 Sonnet', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-5-sonnet-latest': { displayName: 'Claude 3.5 Sonnet v2', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-5-haiku-latest': { displayName: 'Claude 3.5 Haiku', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-haiku-20240307': { displayName: 'Claude 3 Haiku', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-sonnet-20240229': { displayName: 'Claude 3 Sonnet', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-3-opus-20240229': { displayName: 'Claude 3 Opus', url: 'https://api.anthropic.com/v1/messages' },
+	'anthropic/claude-2.1': { displayName: 'Claude 2.1' },
+	'anthropic/claude-instant-1.2': { displayName: 'Claude Instant' },
+	// ... Continue with other providers (truncated for brevity)
+} as const;
+
+/**
+ * Extract provider name from model string (e.g., "openai/gpt-4" -> "openai")
+ */
+export function getProviderFromModel(model: string): string | null {
+	const parts = model.split('/');
+	return parts.length > 1 ? parts[0] : null;
+}
+
+/**
+ * Get model information
+ */
+export function getModelInfo(model: string): ModelInfo | undefined {
+	return supportedModels[model];
+}
+
+/**
+ * List all models for a provider
+ */
+export function listModels(provider?: string): string[] {
+	const models = Object.keys(supportedModels);
+	if (!provider) {
+		return models;
+	}
+	return models.filter((m) => m.startsWith(`${provider}/`));
+}
+
+/**
+ * Check if a model exists
+ */
+export function isModelSupported(model: string): boolean {
+	return model in supportedModels;
+}
+

package/src/types/index.ts

@@ -0,0 +1,81 @@
+// Core types for AI interactions
+
+export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
+
+export interface Message {
+	role: MessageRole;
+	content: string;
+	name?: string;
+	tool_call_id?: string;
+	files?: ImageFile[]; // Multi-modal support: images
+}
+
+export interface ImageFile {
+	url: string;
+	type?: string; // e.g., 'image/jpeg', 'image/png'
+}
+
+export interface ChatOptions {
+	model: string;
+	messages: Message[];
+	apiKey?: string;
+
+	// Common parameters
+	temperature?: number;
+	maxTokens?: number;
+	topP?: number;
+	topK?: number;
+	frequencyPenalty?: number;
+	presencePenalty?: number;
+	stop?: string | string[];
+	stream?: boolean;
+	plain?: boolean; // Plain text mode - returns raw text without JSON/SSE wrapping
+
+	// Provider-specific options
+	providerOptions?: Record<string, any>;
+}
+
+export interface ChatResponse {
+	content: string;
+	finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter' | string;
+	usage?: {
+		promptTokens: number;
+		completionTokens: number;
+		totalTokens: number;
+	};
+	model: string;
+	raw?: any; // Original provider response
+}
+
+export interface StreamChunk {
+	content: string;
+	finishReason?: string;
+	index?: number;
+}
+
+export interface ModelCapabilities {
+	streaming?: boolean;
+	vision?: boolean;
+	imageInput?: boolean;
+	imageGen?: boolean;
+	reasoning?: boolean;
+	noSystem?: boolean; // Doesn't support system messages (o1/o3)
+	noChat?: boolean;
+	noTopPWithTemp?: boolean; // Can't use top_p with temperature
+	responseModalities?: string[];
+	audio?: boolean;
+	video?: boolean;
+}
+
+export interface ModelInfo extends ModelCapabilities {
+	displayName: string;
+	enabled?: boolean;
+	url?: string;
+}
+
+export interface ProviderConfig {
+	apiKey?: string;
+	baseUrl?: string;
+	[key: string]: any;
+}
+

package/src/types/provider.ts

@@ -0,0 +1,19 @@
+import { ChatOptions, ChatResponse, StreamChunk, ProviderConfig } from './index';
+
+export interface IProviderAdapter {
+	/**
+	 * Execute a chat completion request
+	 * @returns ChatResponse for non-streaming, AsyncIterable<StreamChunk> for streaming
+	 */
+	chat(options: ChatOptions): Promise<ChatResponse | AsyncIterable<StreamChunk>>;
+
+	/**
+	 * Get the provider name
+	 */
+	readonly name: string;
+}
+
+export interface ProviderAdapterConstructor {
+	new(config?: ProviderConfig): IProviderAdapter;
+}
+

package/src/types/streaming.ts

@@ -0,0 +1,32 @@
+import { StreamChunk } from './index';
+
+export type StreamCallback = (chunk: StreamChunk) => void;
+
+export interface StreamOptions {
+	onChunk?: StreamCallback;
+	signal?: AbortSignal;
+}
+
+/**
+ * Helper type for streams that can be async iterated
+ */
+export type ChatStream = AsyncIterable<StreamChunk>;
+
+/**
+ * Transform a ReadableStream to AsyncIterable
+ */
+export async function* streamToAsyncIterable(
+	stream: ReadableStream<Uint8Array>
+): AsyncIterable<Uint8Array> {
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+