@qorejs/qore 0.7.2 → 0.9.0

package/dist/src/index.js

@@ -1,10 +1,15 @@
 // Re-export the public runtime surface from a single module entrypoint.
-export { signal, computed, effect, batch, untrack, isSignal } from './core/signal.js';
+export { signal, computed, createRoot, effect, onCleanup, batch, untrack, isSignal } from './core/signal.js';
 export { stream, createStream, from, mapStream, scanStream, toAsyncIterable } from './core/stream.js';
 export { createResponse, response } from './core/response.js';
 export { createApp } from './dom/app.js';
 export { dynamic, fragment, h, list, mount, renderResponse, show, text } from './dom/dom.js';
+export { assertCanUseDOM, canUseDOM } from './dom/scope.js';
+export { createSSEResponse } from './server/sse-response.js';
 export { createAnthropic } from './providers/anthropic.js';
+export { createDeepSeek } from './providers/deepseek.js';
+export { createOllama } from './providers/ollama.js';
 export { createOpenAI } from './providers/openai.js';
-export { createSSEAdapter } from './providers/sse.js';
+export { createOpenRouter } from './providers/openrouter.js';
+export { collectProviderMetadata, createLineAdapter, createSSEAdapter, extractAnthropicMetadata, extractDeepSeekMetadata, extractOllamaMetadata, extractOpenAIMetadata, extractOpenRouterMetadata, mergeProviderMetadata } from './providers/sse.js';
 export { normalizeError, sleep } from './shared/utils.js';

package/dist/src/providers/anthropic.js

@@ -18,7 +18,7 @@ function normalizeMessages(input) {
 }
 // Keep provider setup explicit because real API keys should stay off the client.
 export function createAnthropic(options = {}) {
-    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, version = DEFAULT_VERSION, maxTokens = DEFAULT_MAX_TOKENS, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch } = options;
+    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, version = DEFAULT_VERSION, maxTokens = DEFAULT_MAX_TOKENS, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, retry } = options;
     const resolvedApiKey = apiKey ?? readEnv('ANTHROPIC_API_KEY');
     if (!resolvedApiKey) {
         throw new Error('Qore Anthropic adapter requires an API key. Pass apiKey or set ANTHROPIC_API_KEY.');
@@ -33,8 +33,9 @@ export function createAnthropic(options = {}) {
             ...defaultHeaders
         },
         fetch: fetchImpl,
+        ...(retry ? { retry } : {}),
         buildRequest(request, requestOptions = {}) {
-            const { signal, headers = {}, ...overrides } = requestOptions;
+            const { signal, headers = {}, retry: _retry, ...overrides } = requestOptions;
             const config = {
                 method: 'POST',
                 headers,
@@ -88,14 +89,15 @@ export function createAnthropic(options = {}) {
         },
         // Match the Qore narrative directly: stream(anthropic.chat(prompt)).
         chat(input, requestOptions = {}) {
-            const { signal, headers, ...rest } = requestOptions;
+            const { signal, headers, retry, ...rest } = requestOptions;
             const request = { ...rest };
             if (!('messages' in request)) {
                 request.messages = normalizeMessages(input);
             }
             return streamText(request, {
                 ...(signal ? { signal } : {}),
-                ...(headers ? { headers } : {})
+                ...(headers ? { headers } : {}),
+                ...(retry ? { retry } : {})
             });
         }
     };

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

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

package/dist/src/providers/deepseek.js

@@ -0,0 +1,90 @@
+import { createSSEAdapter, readEnv } from './sse.js';
+const DEFAULT_BASE_URL = 'https://api.deepseek.com';
+const DEFAULT_MODEL = 'deepseek-chat';
+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 createDeepSeek(options = {}) {
+    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, retry } = options;
+    const resolvedApiKey = apiKey ?? readEnv('DEEPSEEK_API_KEY');
+    if (!resolvedApiKey) {
+        throw new Error('Qore DeepSeek adapter requires an API key. Pass apiKey or set DEEPSEEK_API_KEY.');
+    }
+    const transport = createSSEAdapter({
+        name: 'DeepSeek',
+        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/line-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { LineAdapter, LineAdapterOptions } from './types.js';
+export declare function createLineAdapter<TRequest = Record<string, unknown>, TChatInput = unknown, TData = unknown>(options?: LineAdapterOptions<TRequest, TChatInput, TData>): LineAdapter<TRequest, TChatInput, TData>;

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

@@ -0,0 +1,83 @@
+import { normalizeAbortReason, normalizeError } from '../shared/utils.js';
+import { mergeHeaders, readErrorBody } from './sse-env.js';
+import { getLineErrorMessage, isLineError, parseLineData, readLines } from './line-parser.js';
+function isRequestConfig(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+// Expose a generic line-stream adapter so Qore can integrate with NDJSON-style endpoints.
+export function createLineAdapter(options = {}) {
+    const { name = 'LineStream', url: defaultURL, method: defaultMethod = 'POST', headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, buildRequest = null, buildChatRequest = null, parse = parseLineData, isError = isLineError, getError = getLineErrorMessage, lineToText = (event) => typeof event.data === 'string' ? event.data : undefined } = 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`);
+        }
+        if (signal?.aborted) {
+            throw normalizeAbortReason(signal.reason, `${name} request aborted`);
+        }
+        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 readLines(response.body, signal)) {
+            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;
+        }
+    }
+    async function* streamText(request = {}, requestOptions = {}) {
+        for await (const event of stream(request, requestOptions)) {
+            const nextText = await lineToText(event, request, requestOptions);
+            if (typeof nextText === 'string') {
+                yield nextText;
+            }
+        }
+    }
+    return {
+        // Stream parsed line-delimited events from an arbitrary HTTP endpoint.
+        stream,
+        // Stream only the text payload selected by the adapter's lineToText mapping.
+        streamText,
+        // Offer the same narrative shape as provider SDKs when buildChatRequest is supplied.
+        chat(input, requestOptions = {}) {
+            if (typeof buildChatRequest !== 'function') {
+                throw new Error(`Qore ${name} adapter does not define chat(). Use stream() or streamText() instead.`);
+            }
+            return streamText(buildChatRequest(input, requestOptions), requestOptions);
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { LineEvent } from './types.js';
+export declare function readLines(body: ReadableStream<Uint8Array>, signal?: AbortSignal | null): AsyncIterable<LineEvent<string>>;
+export declare function parseLineData(line: string): unknown;
+export declare function isLineError(event: LineEvent<unknown>): boolean;
+export declare function getLineErrorMessage(event: LineEvent<unknown>, name: string): string;

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

@@ -0,0 +1,103 @@
+import { normalizeAbortReason } from '../shared/utils.js';
+// Read newline-delimited streaming bodies without depending on a provider SDK.
+export async function* readLines(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let lineNumber = 0;
+    const abortMessage = 'Line stream aborted';
+    const cancelReader = () => {
+        void reader.cancel(signal?.reason).catch(() => {
+            // Ignore reader cancellation races during abort handling.
+        });
+    };
+    const flushLines = function* (lines) {
+        for (const line of lines) {
+            if (!line) {
+                continue;
+            }
+            lineNumber += 1;
+            yield {
+                line: lineNumber,
+                raw: line,
+                data: line
+            };
+        }
+    };
+    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);
+                }
+                throw error;
+            }
+            const { value, done } = chunk;
+            buffer += decoder.decode(value ?? new Uint8Array(), { stream: !done });
+            const lines = buffer.split(/\r?\n/);
+            buffer = lines.pop() ?? '';
+            for (const event of flushLines(lines)) {
+                yield event;
+            }
+            if (done) {
+                if (signal?.aborted) {
+                    throw normalizeAbortReason(signal.reason, abortMessage);
+                }
+                break;
+            }
+        }
+        if (signal?.aborted) {
+            throw normalizeAbortReason(signal.reason, abortMessage);
+        }
+        if (buffer) {
+            lineNumber += 1;
+            yield {
+                line: lineNumber,
+                raw: buffer,
+                data: buffer
+            };
+        }
+    }
+    finally {
+        signal?.removeEventListener('abort', cancelReader);
+    }
+}
+// Default to JSON payloads when possible, otherwise preserve the raw line text.
+export function parseLineData(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return line;
+    }
+}
+// Surface provider-side error payloads from NDJSON-style streams.
+export function isLineError(event) {
+    return Boolean(event.data
+        && typeof event.data === 'object'
+        && 'error' in event.data
+        && (typeof event.data.error === 'string' || Boolean(event.data.error)));
+}
+// Pull a readable message from the common line-stream error shapes.
+export function getLineErrorMessage(event, name) {
+    if (event.data && typeof event.data === 'object') {
+        const errorRecord = event.data;
+        if (typeof errorRecord.error === 'string') {
+            return errorRecord.error;
+        }
+        return errorRecord.error?.message ?? errorRecord.message ?? `${name} streaming error`;
+    }
+    return `${name} streaming error`;
+}

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

@@ -0,0 +1,8 @@
+import type { AnthropicEvent, DeepSeekEvent, OpenAIEvent, OllamaEvent, OpenRouterEvent, ProviderMetadataUpdate, ProviderStreamMetadata } from './types.js';
+export declare function mergeProviderMetadata(metadata: ProviderStreamMetadata, update: ProviderMetadataUpdate | null | undefined): ProviderStreamMetadata;
+export declare function collectProviderMetadata<TEvent>(provider: string, events: Iterable<TEvent> | AsyncIterable<TEvent>, extract: (event: TEvent) => ProviderMetadataUpdate | null | undefined): Promise<ProviderStreamMetadata>;
+export declare function extractOpenAIMetadata(event: OpenAIEvent): ProviderMetadataUpdate | undefined;
+export declare function extractOpenRouterMetadata(event: OpenRouterEvent): ProviderMetadataUpdate | undefined;
+export declare function extractDeepSeekMetadata(event: DeepSeekEvent): ProviderMetadataUpdate | undefined;
+export declare function extractAnthropicMetadata(event: AnthropicEvent): ProviderMetadataUpdate | undefined;
+export declare function extractOllamaMetadata(event: OllamaEvent): ProviderMetadataUpdate | undefined;

package/dist/src/providers/metadata.js

@@ -0,0 +1,193 @@
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readRecord(value) {
+    return isRecord(value) ? value : null;
+}
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readNullableString(value) {
+    if (value === null) {
+        return null;
+    }
+    return readString(value);
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function toUsage(update) {
+    if (!update) {
+        return undefined;
+    }
+    const inputTokens = readNumber(update.inputTokens);
+    const outputTokens = readNumber(update.outputTokens);
+    const explicitTotal = readNumber(update.totalTokens);
+    const totalTokens = explicitTotal ?? (inputTokens !== undefined && outputTokens !== undefined
+        ? (inputTokens ?? 0) + (outputTokens ?? 0)
+        : undefined);
+    if (inputTokens === undefined && outputTokens === undefined && totalTokens === undefined) {
+        return undefined;
+    }
+    return {
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {})
+    };
+}
+function usageFromOpenAIStyle(raw) {
+    const usage = readRecord(raw);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = readNumber(usage['input_tokens'] ?? usage['prompt_tokens']);
+    const outputTokens = readNumber(usage['output_tokens'] ?? usage['completion_tokens']);
+    const totalTokens = readNumber(usage['total_tokens']);
+    return toUsage({
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {}),
+        ...(totalTokens !== undefined ? { totalTokens } : {})
+    });
+}
+function usageFromAnthropic(raw) {
+    const usage = readRecord(raw);
+    if (!usage) {
+        return undefined;
+    }
+    const inputTokens = readNumber(usage['input_tokens']);
+    const outputTokens = readNumber(usage['output_tokens']);
+    return toUsage({
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {})
+    });
+}
+function usageFromOllama(event) {
+    const inputTokens = readNumber(event['prompt_eval_count']);
+    const outputTokens = readNumber(event['eval_count']);
+    return toUsage({
+        ...(inputTokens !== undefined ? { inputTokens } : {}),
+        ...(outputTokens !== undefined ? { outputTokens } : {})
+    });
+}
+function hasMetadata(update) {
+    return update.responseId !== undefined
+        || update.model !== undefined
+        || update.finishReason !== undefined
+        || update.stopReason !== undefined
+        || update.usage !== undefined;
+}
+function buildMetadataUpdate(fields) {
+    return {
+        ...(fields.responseId !== undefined ? { responseId: fields.responseId } : {}),
+        ...(fields.model !== undefined ? { model: fields.model } : {}),
+        ...(fields.finishReason !== undefined ? { finishReason: fields.finishReason } : {}),
+        ...(fields.stopReason !== undefined ? { stopReason: fields.stopReason } : {}),
+        ...(fields.usage !== undefined ? { usage: fields.usage } : {})
+    };
+}
+export function mergeProviderMetadata(metadata, update) {
+    if (!update) {
+        return metadata;
+    }
+    const hasUsageUpdate = update.usage !== undefined;
+    const mergedInputTokens = update.usage?.inputTokens ?? metadata.usage?.inputTokens;
+    const mergedOutputTokens = update.usage?.outputTokens ?? metadata.usage?.outputTokens;
+    const mergedExplicitTotal = update.usage?.totalTokens ?? (hasUsageUpdate ? undefined : metadata.usage?.totalTokens);
+    const mergedUsage = toUsage({
+        ...(mergedInputTokens !== undefined ? { inputTokens: mergedInputTokens } : {}),
+        ...(mergedOutputTokens !== undefined ? { outputTokens: mergedOutputTokens } : {}),
+        ...(mergedExplicitTotal !== undefined ? { totalTokens: mergedExplicitTotal } : {})
+    });
+    return {
+        provider: metadata.provider,
+        ...(update.responseId !== undefined ? { responseId: update.responseId } : metadata.responseId !== undefined ? { responseId: metadata.responseId } : {}),
+        ...(update.model !== undefined ? { model: update.model } : metadata.model !== undefined ? { model: metadata.model } : {}),
+        ...(update.finishReason !== undefined
+            ? { finishReason: update.finishReason }
+            : metadata.finishReason !== undefined
+                ? { finishReason: metadata.finishReason }
+                : {}),
+        ...(update.stopReason !== undefined
+            ? { stopReason: update.stopReason }
+            : metadata.stopReason !== undefined
+                ? { stopReason: metadata.stopReason }
+                : {}),
+        ...(mergedUsage ? { usage: mergedUsage } : {})
+    };
+}
+export async function collectProviderMetadata(provider, events, extract) {
+    let metadata = { provider };
+    for await (const event of events) {
+        metadata = mergeProviderMetadata(metadata, extract(event));
+    }
+    return metadata;
+}
+export function extractOpenAIMetadata(event) {
+    const response = readRecord(event['response']);
+    if (!response) {
+        return undefined;
+    }
+    const update = buildMetadataUpdate({
+        responseId: readString(response['id']),
+        model: readString(response['model']),
+        finishReason: readNullableString(response['finish_reason']) ?? readNullableString(response['status']),
+        stopReason: undefined,
+        usage: usageFromOpenAIStyle(response['usage'])
+    });
+    return hasMetadata(update) ? update : undefined;
+}
+export function extractOpenRouterMetadata(event) {
+    const firstChoice = Array.isArray(event.choices) ? event.choices[0] : undefined;
+    const finishReason = readNullableString(firstChoice?.finish_reason);
+    const update = buildMetadataUpdate({
+        responseId: readString(event.id),
+        model: readString(event.model),
+        finishReason,
+        stopReason: undefined,
+        usage: usageFromOpenAIStyle(readRecord(event)?.['usage'])
+    });
+    return hasMetadata(update) ? update : undefined;
+}
+export function extractDeepSeekMetadata(event) {
+    return extractOpenRouterMetadata(event);
+}
+export function extractAnthropicMetadata(event) {
+    if (event.type === 'message_start') {
+        const message = readRecord(event['message']);
+        if (!message) {
+            return undefined;
+        }
+        const update = buildMetadataUpdate({
+            responseId: readString(message['id']),
+            model: readString(message['model']),
+            finishReason: undefined,
+            stopReason: undefined,
+            usage: usageFromAnthropic(message['usage'])
+        });
+        return hasMetadata(update) ? update : undefined;
+    }
+    if (event.type === 'message_delta') {
+        const delta = readRecord(event['delta']);
+        const stopReason = readNullableString(delta?.['stop_reason']) ?? readNullableString(delta?.['stop_sequence']);
+        const update = buildMetadataUpdate({
+            responseId: undefined,
+            model: undefined,
+            finishReason: stopReason,
+            stopReason,
+            usage: usageFromAnthropic(event['usage'])
+        });
+        return hasMetadata(update) ? update : undefined;
+    }
+    return undefined;
+}
+export function extractOllamaMetadata(event) {
+    const finishReason = readNullableString(event.done_reason);
+    const update = buildMetadataUpdate({
+        responseId: undefined,
+        model: readString(event.model),
+        finishReason,
+        stopReason: finishReason,
+        usage: usageFromOllama(event)
+    });
+    return hasMetadata(update) ? update : undefined;
+}

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

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

package/dist/src/providers/ollama.js

@@ -0,0 +1,82 @@
+import { createLineAdapter } from './line-adapter.js';
+const DEFAULT_BASE_URL = 'http://127.0.0.1:11434';
+const DEFAULT_MODEL = 'llama3.2';
+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 createOllama(options = {}) {
+    const { baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch } = options;
+    const transport = createLineAdapter({
+        name: 'Ollama',
+        url: `${baseURL}/api/chat`,
+        headers: {
+            'Content-Type': 'application/json',
+            ...defaultHeaders
+        },
+        fetch: fetchImpl,
+        buildRequest(request, requestOptions = {}) {
+            const { signal, headers = {}, ...overrides } = requestOptions;
+            const config = {
+                method: 'POST',
+                headers,
+                body: JSON.stringify({
+                    model,
+                    stream: true,
+                    ...request,
+                    ...overrides
+                })
+            };
+            if (signal) {
+                config.signal = signal;
+            }
+            return config;
+        },
+        parse: (line) => JSON.parse(line),
+        lineToText: (event) => {
+            return typeof event.data?.message?.content === 'string'
+                ? event.data.message.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 {
+        stream(request, requestOptions = {}) {
+            return streamEvents(request, requestOptions);
+        },
+        streamText(input, requestOptions = {}) {
+            return streamText(input, requestOptions);
+        },
+        chat(input, requestOptions = {}) {
+            const { signal, headers, ...rest } = requestOptions;
+            const request = { ...rest };
+            if (!('messages' in request)) {
+                request.messages = normalizeChatInput(input);
+            }
+            return streamText(request, {
+                ...(signal ? { signal } : {}),
+                ...(headers ? { headers } : {})
+            });
+        }
+    };
+}

package/dist/src/providers/openai.js

@@ -16,7 +16,7 @@ function normalizeChatInput(input) {
 }
 // Keep provider setup explicit because real API keys should stay off the client.
 export function createOpenAI(options = {}) {
-    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch } = options;
+    const { apiKey, baseURL = DEFAULT_BASE_URL, model = DEFAULT_MODEL, headers: defaultHeaders = {}, fetch: fetchImpl = globalThis.fetch, retry } = options;
     const resolvedApiKey = apiKey ?? readEnv('OPENAI_API_KEY');
     if (!resolvedApiKey) {
         throw new Error('Qore OpenAI adapter requires an API key. Pass apiKey or set OPENAI_API_KEY.');
@@ -30,8 +30,9 @@ export function createOpenAI(options = {}) {
             ...defaultHeaders
         },
         fetch: fetchImpl,
+        ...(retry ? { retry } : {}),
         buildRequest(request, requestOptions = {}) {
-            const { signal, headers = {}, ...overrides } = requestOptions;
+            const { signal, headers = {}, retry: _retry, ...overrides } = requestOptions;
             const config = {
                 method: 'POST',
                 headers,
@@ -82,14 +83,15 @@ export function createOpenAI(options = {}) {
         },
         // Match the Qore narrative directly: stream(openai.chat(prompt)).
         chat(input, requestOptions = {}) {
-            const { signal, headers, ...rest } = requestOptions;
+            const { signal, headers, retry, ...rest } = requestOptions;
             const request = { ...rest };
             if (!('input' in request)) {
                 request.input = normalizeChatInput(input);
             }
             return streamText(request, {
                 ...(signal ? { signal } : {}),
-                ...(headers ? { headers } : {})
+                ...(headers ? { headers } : {}),
+                ...(retry ? { retry } : {})
             });
         }
     };