@qorejs/qore 0.7.3 → 0.9.0

package/dist/src/core/signal.d.ts

@@ -16,4 +16,5 @@ export declare function signal<T>(initialValue: T): Signal<T>;
 export declare function computed<T>(getter: () => T): ComputedSignal<T>;
 export declare function effect(fn: EffectCallback, options?: EffectOptions): Cleanup;
 export { batch, untrack } from './signal-context.js';
+export { createRoot, onCleanup } from './owner.js';
 export declare function isSignal<T = unknown>(value: unknown): value is ReadonlySignal<T>;

package/dist/src/core/signal.js

@@ -1,3 +1,4 @@
+import { createRoot, onCleanup } from './owner.js';
 import { batch, READ, untrack } from './signal-context.js';
 import { ComputedNode, EffectNode, SignalNode } from './signal-nodes.js';
 // Create a mutable signal function with helper methods attached to it.
@@ -35,6 +36,7 @@ export function effect(fn, options = {}) {
     return () => node.stop();
 }
 export { batch, untrack } from './signal-context.js';
+export { createRoot, onCleanup } from './owner.js';
 // Detect Qore signal-like values by their callable shape plus peek helper.
 export function isSignal(value) {
     return typeof value === 'function' && typeof value.peek === 'function';

package/dist/src/core/stream-types.d.ts

@@ -6,6 +6,7 @@ export interface BackpressureOptions {
     buffer?: number;
     overflow?: OverflowStrategy;
 }
+export type RetryBackoff = number | number[] | 'exponential' | ((retry: number, error: unknown) => MaybePromise<number>);
 export interface NormalizedBackpressure {
     interval: number;
     buffer: number;
@@ -21,6 +22,11 @@ export interface StreamOptions<TChunk = unknown, TValue = string> {
     reduce?: (currentValue: TValue, chunk: TChunk, index: number) => TValue;
     backpressure?: number | BackpressureOptions | null;
 }
+export interface RetryableStreamOptions<TChunk = unknown, TValue = string> extends StreamOptions<TChunk, TValue> {
+    maxRetries?: number;
+    backoff?: RetryBackoff;
+}
+export type StreamPipeStage<TChunk = unknown, TValue = string> = (value: TValue, index: number) => MaybePromise<StreamInput<TChunk, TValue>>;
 export interface StreamController<TChunk = unknown, TValue = string> {
     readonly signal: GlobalAbortSignal;
     push(chunk: TChunk): Promise<TValue>;
@@ -57,5 +63,11 @@ export interface StreamFactory {
     latest<TChunk>(sourceOrSetup: StreamInput<TChunk, TChunk | null>, options?: StreamOptions<TChunk, TChunk | null>): QoreStream<TChunk, TChunk | null>;
     withBackpressure<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, backpressure: number | BackpressureOptions, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
     paced<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, interval: number, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    merge<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    concat<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    pipe<TChunk = unknown, TValue = string>(sourceOrSetup: StreamInput<TChunk, TValue>, stages: Array<StreamPipeStage<TChunk, TValue>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    race<TChunk = unknown, TValue = string>(sources: Array<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    retryable<TChunk = unknown, TValue = string>(sourceFactory: (attempt: number) => StreamInput<TChunk, TValue>, options?: RetryableStreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
+    switchMap<TInput, TChunk = unknown, TValue = string>(source: SourceLike<TInput>, mapper: (value: TInput, index: number) => MaybePromise<SourceLike<TChunk>>, options?: StreamOptions<TChunk, TValue>): QoreStream<TChunk, TValue>;
 }
 export type StreamResponseState<TChunk, TValue> = ResponseState<TChunk, TValue>;

package/dist/src/core/stream.d.ts

@@ -7,5 +7,5 @@ export declare function from<TChunk, TValue = string>(source: SourceLike<TChunk>
 export declare function mapStream<TInput, TOutput, TValue = string>(source: SourceLike<TInput>, mapper: (chunk: TInput, index: number) => MaybePromise<TOutput>, options?: StreamOptions<TOutput, TValue>): QoreStream<TOutput, TValue>;
 export declare function scanStream<TInput, TOutput>(source: SourceLike<TInput>, reducer: (currentValue: TOutput, chunk: TInput, index: number) => MaybePromise<TOutput>, seed: TOutput, options?: Omit<StreamOptions<TOutput, TOutput>, 'seed' | 'reduce'>): QoreStream<TOutput, TOutput>;
 export { createStream } from './stream-runtime.js';
-export type { BackpressureOptions, QoreStream, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './stream-types.js';
+export type { BackpressureOptions, QoreStream, RetryBackoff, RetryableStreamOptions, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './stream-types.js';
 export { toAsyncIterable } from './iterable.js';

package/dist/src/core/stream.js

@@ -1,5 +1,6 @@
 import { toAsyncIterable } from './iterable.js';
 import { createStream } from './stream-runtime.js';
+import { startSource } from './stream-source.js';
 import { reduceText } from './stream-state.js';
 import { sleep } from '../shared/utils.js';
 const streamFactory = ((sourceOrSetup, options = {}) => createStream(sourceOrSetup, {
@@ -36,8 +37,151 @@ streamFactory.withBackpressure = (sourceOrSetup, backpressure, options = {}) =>
 });
 // Shorthand for the first backpressure primitive: minimum interval between chunks.
 streamFactory.paced = (sourceOrSetup, interval, options = {}) => streamFactory.withBackpressure(sourceOrSetup, { interval }, options);
+streamFactory.merge = (sources, options = {}) => createStream(async (controller) => {
+    await Promise.all(sources.map(async (source) => {
+        await startSource(source, controller);
+    }));
+}, options);
+streamFactory.concat = (sources, options = {}) => createStream(async (controller) => {
+    for (const source of sources) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        await startSource(source, controller);
+    }
+}, options);
+streamFactory.pipe = (sourceOrSetup, stages, options = {}) => createStream(async (controller) => {
+    const consumeSource = async (currentSource) => {
+        const currentStream = createStream(currentSource, options);
+        for await (const chunk of currentStream) {
+            if (controller.signal.aborted) {
+                break;
+            }
+            await controller.push(chunk);
+        }
+        return currentStream.ready;
+    };
+    let currentValue = await consumeSource(sourceOrSetup);
+    for (const [index, stage] of stages.entries()) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        const nextSource = await stage(currentValue, index);
+        currentValue = await consumeSource(nextSource);
+    }
+}, options);
+streamFactory.race = (sources, options = {}) => createStream(async (controller) => {
+    const activeIterators = sources.map((source, index) => ({
+        index,
+        iterator: toAsyncIterable(source)[Symbol.asyncIterator]()
+    }));
+    let winner = null;
+    try {
+        while (!controller.signal.aborted && winner === null && activeIterators.length > 0) {
+            const nextResult = await Promise.race(activeIterators.map(async ({ index, iterator }) => ({
+                index,
+                result: await iterator.next()
+            })));
+            if (nextResult.result.done) {
+                const exhaustedIndex = activeIterators.findIndex(({ index }) => index === nextResult.index);
+                if (exhaustedIndex >= 0) {
+                    activeIterators.splice(exhaustedIndex, 1);
+                }
+                continue;
+            }
+            winner = activeIterators.find(({ index }) => index === nextResult.index)?.iterator ?? null;
+            await controller.push(nextResult.result.value);
+        }
+        if (!winner || controller.signal.aborted) {
+            return;
+        }
+        for (const candidate of activeIterators) {
+            if (candidate.iterator !== winner) {
+                await candidate.iterator.return?.();
+            }
+        }
+        while (!controller.signal.aborted) {
+            const nextChunk = await winner.next();
+            if (nextChunk.done) {
+                break;
+            }
+            await controller.push(nextChunk.value);
+        }
+    }
+    finally {
+        for (const { iterator } of activeIterators) {
+            if (iterator !== winner) {
+                await iterator.return?.();
+            }
+        }
+    }
+}, options);
+streamFactory.retryable = (sourceFactory, options = {}) => {
+    const { maxRetries = 0, backoff = 'exponential', ...streamOptions } = options;
+    return createStream(async (controller) => {
+        let retries = 0;
+        while (!controller.signal.aborted) {
+            try {
+                await startSource(sourceFactory(retries), controller);
+                return;
+            }
+            catch (error) {
+                if (retries >= maxRetries || controller.signal.aborted) {
+                    throw error;
+                }
+                retries += 1;
+                const delay = await resolveRetryDelay(backoff, retries, error);
+                if (delay > 0) {
+                    await sleep(delay, controller.signal);
+                }
+            }
+        }
+    }, streamOptions);
+};
+streamFactory.switchMap = (source, mapper, options = {}) => createStream(async (controller) => {
+    let index = 0;
+    let activeToken = 0;
+    let activeTask = null;
+    const startInner = (token, innerSource) => (async () => {
+        for await (const chunk of toAsyncIterable(innerSource)) {
+            if (controller.signal.aborted || token !== activeToken) {
+                break;
+            }
+            await controller.push(chunk);
+        }
+    })().catch((error) => {
+        if (token !== activeToken || controller.signal.aborted) {
+            return;
+        }
+        throw error;
+    });
+    for await (const value of toAsyncIterable(source)) {
+        if (controller.signal.aborted) {
+            break;
+        }
+        activeToken += 1;
+        const token = activeToken;
+        const innerSource = await mapper(value, index);
+        activeTask = startInner(token, innerSource);
+        index += 1;
+    }
+    await activeTask;
+}, options);
 // Create a text-accumulating stream by default.
 export const stream = streamFactory;
+async function resolveRetryDelay(backoff, retry, error) {
+    if (typeof backoff === 'function') {
+        return Math.max(0, await backoff(retry, error));
+    }
+    if (Array.isArray(backoff)) {
+        const nextDelay = backoff[Math.min(retry - 1, backoff.length - 1)] ?? 0;
+        return Math.max(0, nextDelay);
+    }
+    if (backoff === 'exponential') {
+        return 250 * 2 ** (retry - 1);
+    }
+    return Math.max(0, backoff);
+}
 // Turn any iterable or async iterable into a stream, optionally adding source delay.
 export function from(source, options = {}) {
     const { delay = 0, ...streamOptions } = options;

package/dist/src/dom/app.js

@@ -2,11 +2,10 @@ import { dynamic, fragment, h, list, mount, renderResponse, show, text } from '.
 import { batch, computed, effect, signal, untrack } from '../core/signal.js';
 import { response } from '../core/response.js';
 import { from, mapStream, scanStream, stream } from '../core/stream.js';
+import { assertDocument } from './scope.js';
 // Resolve a CSS selector or direct node into the root mount target.
 function resolveTarget(target) {
-    if (typeof document === 'undefined') {
-        throw new Error('Qore app mounting requires a browser-like environment');
-    }
+    assertDocument('createApp(...).mount(...)');
     if (typeof target === 'string') {
         const element = document.querySelector(target);
         if (!element) {

package/dist/src/dom/dom.d.ts

@@ -5,6 +5,7 @@ export declare function dynamic<T>(source: ReactiveValue<T>, render?: (value: T)
 export declare function show<T>(source: ReactiveValue<T>, render?: (value: T) => QoreChild, fallback?: QoreChild | ((value: T) => QoreChild)): QoreDocumentFragment;
 export declare function list<T>(source: ReactiveValue<Iterable<T> | ArrayLike<T> | null | undefined>, render: (item: T, index: number) => QoreChild, options?: {
     fallback?: QoreChild | ((items: T[]) => QoreChild);
+    key?: (item: T, index: number) => unknown;
 }): QoreDocumentFragment;
 export declare function renderResponse<TChunk, TValue>(responseState: ResponseState<TChunk, TValue>, views?: ResponseViews<TChunk, TValue>): QoreDocumentFragment;
 export declare function h(tag: string, props?: Record<string, unknown> | null, ...children: QoreChild[]): QoreElement;

package/dist/src/dom/dom.js

@@ -63,6 +63,27 @@ function replaceRange(start, end, nextValue) {
         parent.insertBefore(node, end);
     }
 }
+function insertBefore(parent, reference, value) {
+    for (const node of materialize(value)) {
+        parent.insertBefore(node, reference);
+    }
+}
+function destroyKeyedEntry(entry) {
+    disposeScope(entry.scope);
+    clearRange(entry.start, entry.end);
+    entry.start.remove();
+    entry.end.remove();
+}
+function renderKeyedEntry(parent, reference, item, index, render) {
+    const start = document.createComment('qore-list-item-start');
+    const end = document.createComment('qore-list-item-end');
+    const scope = createScope();
+    parent.insertBefore(start, reference);
+    const content = withScope(scope, () => render(item, index));
+    insertBefore(parent, reference, content);
+    parent.insertBefore(end, reference);
+    return { key: null, value: item, index, start, end, scope };
+}
 // Allow mount targets to be passed as selectors or direct nodes.
 function resolveRoot(root) {
     if (typeof root === 'string') {
@@ -76,7 +97,7 @@ function resolveRoot(root) {
 }
 // Build a fragment from a variadic list of children.
 export function fragment(...children) {
-    assertDocument();
+    assertDocument('fragment()');
     const node = document.createDocumentFragment();
     for (const child of children) {
         appendChild(node, child);
@@ -85,7 +106,7 @@ export function fragment(...children) {
 }
 // Render a live region between comment markers and refresh it when the source changes.
 export function dynamic(source, render = (value) => value) {
-    assertDocument();
+    assertDocument('dynamic()');
     const start = document.createComment('qore-dynamic-start');
     const end = document.createComment('qore-dynamic-end');
     const node = document.createDocumentFragment();
@@ -115,18 +136,84 @@ export function show(source, render, fallback = null) {
 }
 // Render a list reactively, or a fallback when the collection is empty.
 export function list(source, render, options = {}) {
-    const { fallback = null } = options;
-    return dynamic(source, (value) => {
+    const { fallback = null, key } = options;
+    if (!key) {
+        return dynamic(source, (value) => {
+            const items = value == null
+                ? []
+                : Array.isArray(value)
+                    ? value
+                    : Array.from(value);
+            if (items.length === 0) {
+                return resolveTemplate(fallback, items);
+            }
+            return items.map((item, index) => render(item, index));
+        });
+    }
+    assertDocument('list()');
+    const start = document.createComment('qore-list-start');
+    const end = document.createComment('qore-list-end');
+    const node = document.createDocumentFragment();
+    node.append(start, end);
+    let entries = [];
+    let fallbackScope = null;
+    const stop = effect(() => {
+        const value = resolveAccessor(source);
         const items = value == null
             ? []
             : Array.isArray(value)
                 ? value
                 : Array.from(value);
+        const parent = end.parentNode;
+        if (!parent) {
+            return;
+        }
         if (items.length === 0) {
-            return resolveTemplate(fallback, items);
+            for (const entry of entries) {
+                destroyKeyedEntry(entry);
+            }
+            entries = [];
+            disposeScope(fallbackScope);
+            fallbackScope = createScope();
+            const renderedFallback = withScope(fallbackScope, () => resolveTemplate(fallback, items));
+            replaceRange(start, end, renderedFallback);
+            return;
+        }
+        disposeScope(fallbackScope);
+        fallbackScope = null;
+        const nextKeys = items.map((item, index) => key(item, index));
+        const canAppend = entries.length <= items.length
+            && entries.every((entry, index) => Object.is(entry.key, nextKeys[index]));
+        if (!canAppend) {
+            for (const entry of entries) {
+                destroyKeyedEntry(entry);
+            }
+            clearRange(start, end);
+            entries = [];
+        }
+        if (!canAppend) {
+            for (let index = 0; index < items.length; index += 1) {
+                const entry = renderKeyedEntry(parent, end, items[index], index, render);
+                entry.key = nextKeys[index];
+                entries.push(entry);
+            }
+            return;
+        }
+        for (let index = entries.length; index < items.length; index += 1) {
+            const entry = renderKeyedEntry(parent, end, items[index], index, render);
+            entry.key = nextKeys[index];
+            entries.push(entry);
         }
-        return items.map((item, index) => render(item, index));
     });
+    registerCleanup(() => {
+        stop();
+        disposeScope(fallbackScope);
+        for (const entry of entries) {
+            destroyKeyedEntry(entry);
+        }
+        entries = [];
+    });
+    return node;
 }
 // Render response state through status-aware template overrides.
 export function renderResponse(responseState, views = {}) {
@@ -142,7 +229,7 @@ export function renderResponse(responseState, views = {}) {
     });
 }
 export function h(tag, props = null, ...children) {
-    assertDocument();
+    assertDocument('h()');
     if (typeof tag === 'function') {
         return tag({
             ...(props ?? {}),
@@ -162,7 +249,7 @@ export function h(tag, props = null, ...children) {
 }
 // Create a text node and keep it in sync with a reactive getter when necessary.
 export function text(valueOrGetter) {
-    assertDocument();
+    assertDocument('text()');
     const node = document.createTextNode('');
     if (isReactiveValue(valueOrGetter)) {
         const stop = effect(() => {
@@ -177,7 +264,7 @@ export function text(valueOrGetter) {
 }
 // Mount a view into a root element and return a disposer for its reactive scope.
 export function mount(root, view) {
-    assertDocument();
+    assertDocument('mount()');
     const target = resolveRoot(root);
     target[ROOT_CLEANUP]?.();
     const scope = createScope();

package/dist/src/dom/scope.d.ts

@@ -3,7 +3,9 @@ export declare const ROOT_CLEANUP: unique symbol;
 export interface Scope {
     cleanups: Cleanup[];
 }
-export declare function assertDocument(): void;
+export declare function canUseDOM(): boolean;
+export declare function assertCanUseDOM(apiName?: string): void;
+export declare function assertDocument(apiName?: string): void;
 export declare function createScope(): Scope;
 export declare function withScope<T>(scope: Scope, fn: () => T): T;
 export declare function registerCleanup<T extends Cleanup | null | undefined>(cleanup: T): T;

package/dist/src/dom/scope.js

@@ -1,12 +1,19 @@
 // Store mount cleanup directly on the root node so remounts can tear down old scopes.
 export const ROOT_CLEANUP = Symbol('qore.dom.cleanup');
 let activeScope = null;
+// Detect whether the current runtime can create and mutate real DOM nodes.
+export function canUseDOM() {
+    return typeof document !== 'undefined';
+}
 // Guard DOM helpers so they only run in browser-like environments.
-export function assertDocument() {
-    if (typeof document === 'undefined') {
-        throw new Error('Qore DOM APIs require a browser-like environment');
+export function assertCanUseDOM(apiName = 'Qore DOM APIs') {
+    if (!canUseDOM()) {
+        throw new Error(`${apiName} requires a browser-like environment`);
     }
 }
+export function assertDocument(apiName = 'Qore DOM APIs') {
+    assertCanUseDOM(apiName);
+}
 // A scope collects effect disposers created while rendering a subtree.
 export function createScope() {
     return { cleanups: [] };

package/dist/src/index.d.ts

@@ -1,16 +1,22 @@
-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 type { ComputedSignal, ReadonlySignal, Signal } from './core/signal.js';
 export type { EffectOptions, EffectScheduler, SubscribeOptions } from './core/signal-types.js';
 export { stream, createStream, from, mapStream, scanStream, toAsyncIterable } from './core/stream.js';
-export type { BackpressureOptions, QoreStream, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './core/stream.js';
+export type { BackpressureOptions, QoreStream, RetryBackoff, RetryableStreamOptions, StreamController, StreamFactory, StreamInput, StreamOptions, StreamSetup } from './core/stream.js';
 export { createResponse, response } from './core/response.js';
 export type { CreateResponseOptions, GlobalAbortSignal, MaybePromise, ResponseConsumeContext, ResponseExecutorContext, ResponseFactory, ResponseReactiveState, ResponseRunOptions, ResponseSnapshot, ResponseSource, ResponseSourceFactory, ResponseState, ResponseStatus, SourceLike } from './core/response.js';
 export { createApp } from './dom/app.js';
 export type { AppContext, AppSetupResult, QoreApp } 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 type { CreateSSEResponseOptions, SSEFrame } from './server/sse-response.js';
 export type { GlobalDocumentFragment, GlobalElement, GlobalNode, GlobalText, MountTarget, MountView, QoreChild, QoreComponent, QoreDocumentFragment, QoreElement, QoreNode, QoreTemplate, QoreText, ReactiveValue, ResponseRenderState, ResponseViews } from './dom/types.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 type { AnthropicAdapter, AnthropicChatInput, AnthropicEvent, AnthropicMessage, AnthropicOptions, AnthropicRequest, FetchLike, OpenAIAdapter, OpenAIChatInput, OpenAIEvent, OpenAIMessage, OpenAIOptions, OpenAIRequest, ProviderHeaders, ProviderRequestOptions, SSEAdapter, SSEAdapterOptions, SSEEvent, SSERequestConfig } 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 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 './providers/sse.js';
 export { normalizeError, sleep } from './shared/utils.js';

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>;