@qorejs/qore 0.7.2 → 0.9.0

package/dist/src/providers/openrouter.d.ts

@@ -0,0 +1,2 @@
+import type { OpenRouterAdapter, OpenRouterOptions } from './types.js';
+export declare function createOpenRouter(options?: OpenRouterOptions): OpenRouterAdapter;

package/dist/src/providers/openrouter.js

@@ -0,0 +1,90 @@
+import { createSSEAdapter, readEnv } from './sse.js';
+const DEFAULT_BASE_URL = 'https://openrouter.ai/api/v1';
+const DEFAULT_MODEL = 'openai/gpt-4.1-mini';
+function normalizeChatInput(input) {
+    if (typeof input === 'string') {
+        return [{ role: 'user', content: input }];
+    }
+    if (Array.isArray(input)) {
+        return input;
+    }
+    if (input && typeof input === 'object' && 'role' in input) {
+        return [input];
+    }
+    return input;
+}
+export function createOpenRouter(options = {}) {
+    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, retry } = options;
+    const resolvedApiKey = apiKey ?? readEnv('OPENROUTER_API_KEY');
+    if (!resolvedApiKey) {
+        throw new Error('Qore OpenRouter adapter requires an API key. Pass apiKey or set OPENROUTER_API_KEY.');
+    }
+    const transport = createSSEAdapter({
+        name: 'OpenRouter',
+        url: `${baseURL}/chat/completions`,
+        headers: {
+            Authorization: `Bearer ${resolvedApiKey}`,
+            'Content-Type': 'application/json',
+            ...defaultHeaders
+        },
+        fetch: fetchImpl,
+        ...(retry ? { retry } : {}),
+        buildRequest(request, requestOptions = {}) {
+            const { signal, headers = {}, retry: _retry, ...overrides } = requestOptions;
+            const config = {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    model,
+                    stream: true,
+                    ...request,
+                    ...overrides
+                })
+            };
+            if (signal) {
+                config.signal = signal;
+            }
+            return config;
+        },
+        parse: (data) => JSON.parse(data),
+        eventToText: (event) => {
+            const nextChoice = event.data?.choices?.[0];
+            return typeof nextChoice?.delta?.content === 'string'
+                ? nextChoice.delta.content
+                : undefined;
+        }
+    });
+    async function* streamEvents(request, requestOptions = {}) {
+        for await (const event of transport.stream(request, requestOptions)) {
+            yield event.data;
+        }
+    }
+    async function* streamText(input, requestOptions = {}) {
+        const request = input && typeof input === 'object' && 'messages' in input
+            ? input
+            : { messages: input };
+        for await (const chunk of transport.streamText(request, requestOptions)) {
+            yield chunk;
+        }
+    }
+    return {
+        chatCompletions: {
+            stream: streamEvents
+        },
+        streamText(input, requestOptions = {}) {
+            return streamText(input, requestOptions);
+        },
+        chat(input, requestOptions = {}) {
+            const { signal, headers, retry, ...rest } = requestOptions;
+            const request = { ...rest };
+            if (!('messages' in request)) {
+                request.messages = normalizeChatInput(input);
+            }
+            return streamText(request, {
+                ...(signal ? { signal } : {}),
+                ...(headers ? { headers } : {}),
+                ...(retry ? { retry } : {})
+            });
+        }
+    };
+}

package/dist/src/providers/sse-adapter.js

@@ -1,62 +1,147 @@
-import { normalizeError } from '../shared/utils.js';
+import { normalizeAbortReason, normalizeError, sleep } from '../shared/utils.js';
 import { mergeHeaders, readErrorBody } from './sse-env.js';
 import { getErrorMessage, isErrorEvent, parseEventData, readSSE } from './sse-parser.js';
 function isRequestConfig(value) {
     return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
+function toRetryableProviderError(error) {
+    return normalizeError(error);
+}
+function withStatus(error, status) {
+    const nextError = error;
+    nextError.status = status;
+    return nextError;
+}
+function normalizeRetryOptions(options, overrides) {
+    return {
+        maxAttempts: overrides?.maxAttempts ?? options?.maxAttempts ?? 1,
+        backoff: overrides?.backoff ?? options?.backoff ?? 'exponential',
+        resume: overrides?.resume ?? options?.resume ?? true,
+        retryOn: overrides?.retryOn ?? options?.retryOn
+    };
+}
+async function shouldRetry(error, attempt, options) {
+    if (attempt >= options.maxAttempts) {
+        return false;
+    }
+    if (typeof options.retryOn === 'function') {
+        return options.retryOn(error, attempt);
+    }
+    if (typeof error.status === 'number') {
+        return error.status === 408
+            || error.status === 409
+            || error.status === 425
+            || error.status === 429
+            || error.status >= 500;
+    }
+    return true;
+}
+async function resolveRetryDelay(options, attempt, error, retryHint) {
+    if (retryHint !== null && retryHint >= 0) {
+        return retryHint;
+    }
+    const { backoff = 'exponential' } = options;
+    if (typeof backoff === 'function') {
+        return Math.max(0, await backoff(attempt, error, retryHint));
+    }
+    if (Array.isArray(backoff)) {
+        return Math.max(0, backoff[Math.min(attempt - 1, backoff.length - 1)] ?? 0);
+    }
+    if (backoff === 'exponential') {
+        return 250 * 2 ** (attempt - 1);
+    }
+    return Math.max(0, backoff);
+}
 // Expose a generic SSE adapter so Qore can integrate with any token-streaming endpoint.
 export function createSSEAdapter(options = {}) {
-    const { name = 'SSE', url: defaultURL, method: defaultMethod = 'POST', headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, buildRequest = null, buildChatRequest = null, parse = parseEventData, isError = isErrorEvent, getError = getErrorMessage, eventToText = (event) => typeof event.data === 'string' ? event.data : undefined } = options;
+    const { name = 'SSE', url: defaultURL, method: defaultMethod = 'POST', headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, buildRequest = null, buildChatRequest = null, parse = parseEventData, isError = isErrorEvent, getError = getErrorMessage, eventToText = (event) => typeof event.data === 'string' ? event.data : undefined, retry: defaultRetry } = options;
     if (typeof fetchImpl !== 'function') {
         throw new Error(`Qore ${name} adapter requires fetch in the current runtime`);
     }
     async function* stream(request = {}, requestOptions = {}) {
-        const builtRequest = buildRequest
-            ? await buildRequest(request, requestOptions)
-            : request;
-        const requestConfig = isRequestConfig(builtRequest)
-            ? builtRequest
-            : { body: builtRequest };
-        const { url = defaultURL, method = defaultMethod, headers: requestHeaders = {}, signal: requestSignal, ...init } = requestConfig;
-        const { signal: overrideSignal, headers: overrideHeaders = {} } = requestOptions;
-        const signal = requestSignal ?? overrideSignal;
-        if (!url) {
-            throw new Error(`Qore ${name} adapter requires a request URL`);
-        }
-        const initConfig = {
-            method,
-            headers: mergeHeaders(defaultHeaders, mergeHeaders(requestHeaders, overrideHeaders)),
-            ...init
-        };
-        if (signal) {
-            initConfig.signal = signal;
-        }
-        const response = await fetchImpl(url, initConfig);
-        if (!response.ok) {
-            throw new Error(await readErrorBody(response));
-        }
-        if (!response.body) {
-            throw new Error(`${name} streaming response did not include a readable body`);
-        }
-        for await (const rawEvent of readSSE(response.body)) {
-            if (!rawEvent.data || rawEvent.data === '[DONE]') {
-                continue;
-            }
-            let parsedEvent;
+        const { signal: overrideSignal, headers: overrideHeaders = {}, retry: overrideRetry } = requestOptions;
+        const retry = normalizeRetryOptions(defaultRetry, overrideRetry);
+        let attempt = 0;
+        let lastEventId = null;
+        let retryHint = null;
+        let activeSignal = overrideSignal ?? null;
+        while (true) {
+            attempt += 1;
             try {
-                parsedEvent = await parse(rawEvent.data, rawEvent);
+                const builtRequest = buildRequest
+                    ? await buildRequest(request, requestOptions)
+                    : request;
+                const requestConfig = isRequestConfig(builtRequest)
+                    ? builtRequest
+                    : { body: builtRequest };
+                const { url = defaultURL, method = defaultMethod, headers: requestHeaders = {}, signal: requestSignal, ...init } = requestConfig;
+                const signal = requestSignal ?? overrideSignal;
+                activeSignal = signal ?? null;
+                if (!url) {
+                    throw new Error(`Qore ${name} adapter requires a request URL`);
+                }
+                if (signal?.aborted) {
+                    throw normalizeAbortReason(signal.reason, `${name} request aborted`);
+                }
+                const resumeHeaders = retry.resume && lastEventId
+                    ? { 'Last-Event-ID': lastEventId }
+                    : {};
+                const initConfig = {
+                    method,
+                    headers: mergeHeaders(defaultHeaders, mergeHeaders(requestHeaders, mergeHeaders(overrideHeaders, resumeHeaders))),
+                    ...init
+                };
+                if (signal) {
+                    initConfig.signal = signal;
+                }
+                const response = await fetchImpl(url, initConfig);
+                if (!response.ok) {
+                    throw withStatus(new Error(await readErrorBody(response)), response.status);
+                }
+                if (!response.body) {
+                    throw new Error(`${name} streaming response did not include a readable body`);
+                }
+                for await (const rawEvent of readSSE(response.body, signal)) {
+                    if (rawEvent.id) {
+                        lastEventId = rawEvent.id;
+                    }
+                    if (rawEvent.retry !== null) {
+                        retryHint = rawEvent.retry;
+                    }
+                    if (!rawEvent.data || rawEvent.data === '[DONE]') {
+                        continue;
+                    }
+                    let parsedEvent;
+                    try {
+                        parsedEvent = await parse(rawEvent.data, rawEvent);
+                    }
+                    catch (error) {
+                        throw normalizeError(error);
+                    }
+                    const nextEvent = {
+                        ...rawEvent,
+                        data: parsedEvent
+                    };
+                    if (await isError(nextEvent)) {
+                        throw new Error(await getError(nextEvent, name));
+                    }
+                    yield nextEvent;
+                }
+                return;
             }
             catch (error) {
-                throw normalizeError(error);
-            }
-            const nextEvent = {
-                ...rawEvent,
-                data: parsedEvent
-            };
-            if (await isError(nextEvent)) {
-                throw new Error(await getError(nextEvent, name));
+                const normalizedError = toRetryableProviderError(error);
+                if (activeSignal?.aborted || overrideSignal?.aborted) {
+                    throw normalizedError;
+                }
+                if (!await shouldRetry(normalizedError, attempt, retry)) {
+                    throw normalizedError;
+                }
+                const delay = await resolveRetryDelay(retry, attempt, normalizedError, retryHint);
+                if (delay > 0) {
+                    await sleep(delay, overrideSignal ?? null);
+                }
             }
-            yield nextEvent;
         }
     }
     async function* streamText(request = {}, requestOptions = {}) {

package/dist/src/providers/sse-parser.d.ts

@@ -1,5 +1,5 @@
 import type { SSEEvent } from './types.js';
-export declare function readSSE(body: ReadableStream<Uint8Array>): AsyncIterable<SSEEvent<string>>;
+export declare function readSSE(body: ReadableStream<Uint8Array>, signal?: AbortSignal | null): AsyncIterable<SSEEvent<string>>;
 export declare function parseEventData(data: string): unknown;
 export declare function isErrorEvent(event: SSEEvent<unknown>): boolean;
 export declare function getErrorMessage(event: SSEEvent<unknown>, name: string): string;

package/dist/src/providers/sse-parser.js

@@ -1,5 +1,6 @@
+import { normalizeAbortReason } from '../shared/utils.js';
 // Parse server-sent events without adding any transport dependency.
-export async function* readSSE(body) {
+export async function* readSSE(body, signal) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
@@ -7,6 +8,12 @@ export async function* readSSE(body) {
     let eventId = null;
     let retry = null;
     let data = [];
+    const abortMessage = 'SSE stream aborted';
+    const cancelReader = () => {
+        void reader.cancel(signal?.reason).catch(() => {
+            // Ignore reader cancellation races during abort handling.
+        });
+    };
     const flushEvent = () => {
         if (data.length === 0) {
             eventName = 'message';
@@ -26,51 +33,80 @@ export async function* readSSE(body) {
         data = [];
         return nextEvent;
     };
-    while (true) {
-        const { value, done } = await reader.read();
-        buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
-        const lines = buffer.split(/\r?\n/);
-        buffer = lines.pop() ?? '';
-        for (const line of lines) {
-            if (!line) {
-                const nextEvent = flushEvent();
-                if (nextEvent) {
-                    yield nextEvent;
+    if (signal?.aborted) {
+        cancelReader();
+        throw normalizeAbortReason(signal.reason, abortMessage);
+    }
+    signal?.addEventListener('abort', cancelReader, { once: true });
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                throw normalizeAbortReason(signal.reason, abortMessage);
+            }
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch (error) {
+                if (signal?.aborted) {
+                    throw normalizeAbortReason(signal.reason, abortMessage);
                 }
-                continue;
+                throw error;
             }
-            if (line.startsWith(':')) {
-                continue;
+            const { value, done } = chunk;
+            buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line) {
+                    const nextEvent = flushEvent();
+                    if (nextEvent) {
+                        yield nextEvent;
+                    }
+                    continue;
+                }
+                if (line.startsWith(':')) {
+                    continue;
+                }
+                const separator = line.indexOf(':');
+                const field = separator === -1 ? line : line.slice(0, separator);
+                const rawValue = separator === -1 ? '' : line.slice(separator + 1).replace(/^ /, '');
+                switch (field) {
+                    case 'event':
+                        eventName = rawValue || 'message';
+                        break;
+                    case 'data':
+                        data.push(rawValue);
+                        break;
+                    case 'id':
+                        eventId = rawValue;
+                        break;
+                    case 'retry': {
+                        const parsedRetry = Number.parseInt(rawValue, 10);
+                        retry = Number.isNaN(parsedRetry) ? null : parsedRetry;
+                        break;
+                    }
+                    default:
+                        break;
+                }
             }
-            const separator = line.indexOf(':');
-            const field = separator === -1 ? line : line.slice(0, separator);
-            const rawValue = separator === -1 ? '' : line.slice(separator + 1).replace(/^ /, '');
-            switch (field) {
-                case 'event':
-                    eventName = rawValue || 'message';
-                    break;
-                case 'data':
-                    data.push(rawValue);
-                    break;
-                case 'id':
-                    eventId = rawValue;
-                    break;
-                case 'retry': {
-                    const parsedRetry = Number.parseInt(rawValue, 10);
-                    retry = Number.isNaN(parsedRetry) ? null : parsedRetry;
-                    break;
+            if (done) {
+                if (signal?.aborted) {
+                    throw normalizeAbortReason(signal.reason, abortMessage);
                 }
-                default:
-                    break;
+                break;
             }
         }
-        if (done) {
-            break;
+        if (signal?.aborted) {
+            throw normalizeAbortReason(signal.reason, abortMessage);
+        }
+        const finalEvent = flushEvent();
+        if (finalEvent) {
+            yield finalEvent;
         }
     }
-    const finalEvent = flushEvent();
-    if (finalEvent) {
-        yield finalEvent;
+    finally {
+        signal?.removeEventListener('abort', cancelReader);
     }
 }
 // Default to JSON payloads when possible, otherwise preserve the raw text event body.

package/dist/src/providers/sse.d.ts

@@ -1,4 +1,10 @@
+export { createDeepSeek } from './deepseek.js';
+export { createLineAdapter } from './line-adapter.js';
+export { collectProviderMetadata, extractAnthropicMetadata, extractDeepSeekMetadata, extractOllamaMetadata, extractOpenAIMetadata, extractOpenRouterMetadata, mergeProviderMetadata } from './metadata.js';
+export { readLines, parseLineData, isLineError, getLineErrorMessage } from './line-parser.js';
+export { createOllama } from './ollama.js';
 export { createSSEAdapter } from './sse-adapter.js';
 export { readEnv, readErrorBody, mergeHeaders } from './sse-env.js';
 export { readSSE, parseEventData, isErrorEvent, getErrorMessage } from './sse-parser.js';
-export type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, FetchLike, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, ProviderHeaders, ProviderRequestOptions, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } from './types.js';
+export { createOpenRouter } from './openrouter.js';
+export type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, DeepSeekAdapter, DeepSeekChatInput, DeepSeekEvent, DeepSeekMessage, DeepSeekOptions, DeepSeekRequest, FetchLike, LineAdapter, LineAdapterOptions, LineEvent, LineRequestConfig, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, OllamaAdapter, OllamaChatInput, OllamaEvent, OllamaMessage, OllamaOptions, OllamaRequest, OpenRouterAdapter, OpenRouterChatInput, OpenRouterEvent, OpenRouterMessage, OpenRouterOptions, OpenRouterRequest, ProviderHeaders, ProviderMetadataUpdate, ProviderRetryBackoff, ProviderRetryOptions, ProviderRequestOptions, ProviderStreamMetadata, ProviderUsage, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } from './types.js';

package/dist/src/providers/sse.js

@@ -1,3 +1,9 @@
+export { createDeepSeek } from './deepseek.js';
+export { createLineAdapter } from './line-adapter.js';
+export { collectProviderMetadata, extractAnthropicMetadata, extractDeepSeekMetadata, extractOllamaMetadata, extractOpenAIMetadata, extractOpenRouterMetadata, mergeProviderMetadata } from './metadata.js';
+export { readLines, parseLineData, isLineError, getLineErrorMessage } from './line-parser.js';
+export { createOllama } from './ollama.js';
 export { createSSEAdapter } from './sse-adapter.js';
 export { readEnv, readErrorBody, mergeHeaders } from './sse-env.js';
 export { readSSE, parseEventData, isErrorEvent, getErrorMessage } from './sse-parser.js';
+export { createOpenRouter } from './openrouter.js';

package/dist/src/providers/types.d.ts

@@ -1,8 +1,32 @@
 import type { GlobalAbortSignal, MaybePromise } from '../core/response.js';
 export type ProviderHeaders = Record<string, string>;
+export type ProviderRetryBackoff = number | number[] | 'exponential' | ((attempt: number, error: unknown, retryHint: number | null) => MaybePromise<number>);
+export interface ProviderRetryOptions {
+    maxAttempts?: number;
+    backoff?: ProviderRetryBackoff;
+    resume?: boolean;
+    retryOn?: (error: unknown, attempt: number) => MaybePromise<boolean>;
+}
+export interface ProviderUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface ProviderStreamMetadata {
+    provider: string;
+    responseId?: string;
+    model?: string;
+    finishReason?: string | null;
+    stopReason?: string | null;
+    usage?: ProviderUsage;
+}
+export interface ProviderMetadataUpdate extends Omit<Partial<ProviderStreamMetadata>, 'usage'> {
+    usage?: Partial<ProviderUsage>;
+}
 export interface ProviderRequestOptions {
     signal?: GlobalAbortSignal;
     headers?: ProviderHeaders;
+    retry?: ProviderRetryOptions;
     [key: string]: unknown;
 }
 export interface SSEEvent<TData = unknown> {
@@ -32,12 +56,44 @@ export interface SSEAdapterOptions<TRequest = Record<string, unknown>, TChatInpu
     isError?: (event: SSEEvent<TData>) => MaybePromise<boolean>;
     getError?: (event: SSEEvent<TData>, name: string) => MaybePromise<string>;
     eventToText?: (event: SSEEvent<TData>, request: TRequest, requestOptions?: ProviderRequestOptions) => MaybePromise<string | undefined>;
+    retry?: ProviderRetryOptions;
 }
 export interface SSEAdapter<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown> {
     stream(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<SSEEvent<TData>>;
     streamText(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
     chat(input: TChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
 }
+export interface LineEvent<TData = unknown> {
+    line: number;
+    raw: string;
+    data: TData;
+}
+export interface LineRequestConfig {
+    url?: string;
+    method?: string;
+    headers?: ProviderHeaders;
+    signal?: GlobalAbortSignal;
+    body?: BodyInit | null;
+    [key: string]: unknown;
+}
+export interface LineAdapterOptions<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown> {
+    name?: string;
+    url?: string;
+    method?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+    buildRequest?: (request: TRequest, requestOptions?: ProviderRequestOptions) => MaybePromise<TRequest | string | LineRequestConfig>;
+    buildChatRequest?: (input: TChatInput, requestOptions?: ProviderRequestOptions) => TRequest;
+    parse?: (line: string, event: LineEvent<string>) => MaybePromise<TData>;
+    isError?: (event: LineEvent<TData>) => MaybePromise<boolean>;
+    getError?: (event: LineEvent<TData>, name: string) => MaybePromise<string>;
+    lineToText?: (event: LineEvent<TData>, request: TRequest, requestOptions?: ProviderRequestOptions) => MaybePromise<string | undefined>;
+}
+export interface LineAdapter<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown> {
+    stream(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<LineEvent<TData>>;
+    streamText(request?: TRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: TChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}
 export interface OpenAIEvent {
     type: string;
     [key: string]: unknown;
@@ -56,6 +112,7 @@ export interface OpenAIOptions {
     model?: string;
     headers?: ProviderHeaders;
     fetch?: FetchLike;
+    retry?: ProviderRetryOptions;
 }
 export interface OpenAIAdapter {
     responses: {
@@ -64,6 +121,61 @@ export interface OpenAIAdapter {
     streamText(input: string | OpenAIRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
     chat(input: OpenAIChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
 }
+export interface OpenRouterEvent {
+    id?: string;
+    model?: string;
+    choices?: Array<{
+        index?: number;
+        finish_reason?: string | null;
+        delta?: {
+            role?: string;
+            content?: string;
+            [key: string]: unknown;
+        };
+    }>;
+    [key: string]: unknown;
+}
+export type OpenRouterMessage = OpenAIMessage;
+export type OpenRouterChatInput = string | OpenRouterMessage | OpenRouterMessage[] | Record<string, unknown>;
+export type OpenRouterRequest = Record<string, unknown> & {
+    messages?: OpenRouterChatInput;
+};
+export interface OpenRouterOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+    retry?: ProviderRetryOptions;
+}
+export interface OpenRouterAdapter {
+    chatCompletions: {
+        stream(request: OpenRouterRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<OpenRouterEvent>;
+    };
+    streamText(input: string | OpenRouterRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: OpenRouterChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}
+export type DeepSeekEvent = OpenRouterEvent;
+export type DeepSeekMessage = OpenRouterMessage;
+export type DeepSeekChatInput = string | DeepSeekMessage | DeepSeekMessage[] | Record<string, unknown>;
+export type DeepSeekRequest = Record<string, unknown> & {
+    messages?: DeepSeekChatInput;
+};
+export interface DeepSeekOptions {
+    apiKey?: string;
+    baseURL?: string;
+    model?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+    retry?: ProviderRetryOptions;
+}
+export interface DeepSeekAdapter {
+    chatCompletions: {
+        stream(request: DeepSeekRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<DeepSeekEvent>;
+    };
+    streamText(input: string | DeepSeekRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: DeepSeekChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}
 export interface AnthropicEvent {
     type: string;
     [key: string]: unknown;
@@ -84,6 +196,7 @@ export interface AnthropicOptions {
     maxTokens?: number;
     headers?: ProviderHeaders;
     fetch?: FetchLike;
+    retry?: ProviderRetryOptions;
 }
 export interface AnthropicAdapter {
     messages: {
@@ -92,3 +205,35 @@ export interface AnthropicAdapter {
     streamText(messages: string | AnthropicRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
     chat(input: AnthropicChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
 }
+export interface OllamaEvent {
+    model?: string;
+    created_at?: string;
+    message?: {
+        role?: string;
+        content?: string;
+        [key: string]: unknown;
+    };
+    done?: boolean;
+    done_reason?: string | null;
+    error?: string;
+    [key: string]: unknown;
+}
+export type OllamaMessage = Record<string, unknown> & {
+    role?: string;
+    content?: unknown;
+};
+export type OllamaChatInput = string | OllamaMessage | OllamaMessage[] | Record<string, unknown>;
+export type OllamaRequest = Record<string, unknown> & {
+    messages?: OllamaChatInput;
+};
+export interface OllamaOptions {
+    baseURL?: string;
+    model?: string;
+    headers?: ProviderHeaders;
+    fetch?: FetchLike;
+}
+export interface OllamaAdapter {
+    stream(request: OllamaRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<OllamaEvent>;
+    streamText(input: string | OllamaRequest, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+    chat(input: OllamaChatInput, requestOptions?: ProviderRequestOptions): AsyncIterable<string>;
+}

package/dist/src/server/sse-response.d.ts

@@ -0,0 +1,16 @@
+import type { GlobalAbortSignal, MaybePromise, SourceLike } from '../core/response.js';
+export interface SSEFrame<TChunk = unknown> {
+    event?: string;
+    id?: string;
+    retry?: number;
+    data: TChunk;
+}
+export interface CreateSSEResponseOptions<TChunk = unknown> {
+    signal?: GlobalAbortSignal;
+    headers?: Record<string, string>;
+    event?: string;
+    doneFrame?: string | false;
+    encode?: (chunk: TChunk, index: number) => MaybePromise<SSEFrame<string> | string>;
+    onError?: (error: Error) => MaybePromise<SSEFrame<string> | string | false>;
+}
+export declare function createSSEResponse<TChunk>(source: SourceLike<TChunk>, options?: CreateSSEResponseOptions<TChunk>): Response;