solid-drift 0.24.0 → 0.26.0

package/dist/stream.js

@@ -0,0 +1,430 @@
+import { createSignal, onCleanup } from "solid-js";
+/**
+ * Feed raw text chunks through the SSE framing rules and call
+ * `onEvent` for each dispatched event. Handles events split across
+ * chunk boundaries, multi-line `data:` payloads, and `:` comments.
+ */
+export function createSSEParser(onEvent) {
+    let buffer = "";
+    let event = "message";
+    let data = [];
+    let id;
+    const dispatch = () => {
+        if (data.length === 0 && event === "message") {
+            event = "message";
+            id = undefined;
+            return;
+        }
+        onEvent({ event, data: data.join("\n"), ...(id ? { id } : {}) });
+        event = "message";
+        data = [];
+        id = undefined;
+    };
+    return (chunk) => {
+        buffer += chunk;
+        let nl;
+        while ((nl = buffer.indexOf("\n")) >= 0) {
+            let line = buffer.slice(0, nl);
+            buffer = buffer.slice(nl + 1);
+            if (line.endsWith("\r"))
+                line = line.slice(0, -1);
+            if (line === "") {
+                dispatch();
+                continue;
+            }
+            if (line.startsWith(":"))
+                continue; // comment / keep-alive
+            const colon = line.indexOf(":");
+            let field = line;
+            let value = "";
+            if (colon >= 0) {
+                field = line.slice(0, colon);
+                value = line.slice(colon + 1);
+                if (value.startsWith(" "))
+                    value = value.slice(1);
+            }
+            if (field === "event")
+                event = value;
+            else if (field === "data")
+                data.push(value);
+            else if (field === "id")
+                id = value;
+            // "retry:" is noted but reconnection stays manual: call connect().
+        }
+    };
+}
+/**
+ * Read a fetch Response body as SSE, dispatching parsed events.
+ * Resolves when the stream ends cleanly; rejects on HTTP errors.
+ */
+async function pumpSSE(response, onEvent, signal) {
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Stream request failed: ${response.status} ${response.statusText}${body ? ` - ${body.slice(0, 200)}` : ""}`);
+    }
+    const feed = createSSEParser(onEvent);
+    const reader = response.body?.getReader();
+    if (!reader)
+        return;
+    const decoder = new TextDecoder();
+    try {
+        for (;;) {
+            if (signal.aborted)
+                return;
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            feed(decoder.decode(value, { stream: true }));
+        }
+    }
+    finally {
+        feed(decoder.decode());
+        reader.releaseLock();
+    }
+}
+/**
+ * A fetch-based Server-Sent Events client.
+ *
+ * Unlike `EventSource`, this works with any HTTP method and custom
+ * headers, so it can reach authenticated or POST-style SSE endpoints.
+ * There is no automatic reconnection: a dropped stream moves to
+ * "closed" (or "error") and `connect()` re-opens it manually.
+ *
+ * SSR-safe: nothing connects until `connect()` runs (or
+ * `autoConnect` fires on the client).
+ *
+ * ```ts
+ * const sse = createSSE("https://api.example.com/events", {
+ *   headers: { Authorization: `Bearer ${token}` },
+ *   onEvent: (ev) => console.log(ev.event, ev.data),
+ * });
+ * sse.disconnect();
+ * ```
+ */
+export function createSSE(url, options = {}) {
+    const { method = "GET", headers, body, event: eventFilter, onEvent, onOpen, onDone, onError, autoConnect = true, fetchFn, } = options;
+    const [status, setStatus] = createSignal("idle");
+    const [events, setEvents] = createSignal([]);
+    const [lastEvent, setLastEvent] = createSignal(null);
+    const [error, setError] = createSignal(null);
+    let controller = null;
+    const disconnect = () => {
+        controller?.abort();
+        controller = null;
+        if (status() === "connecting" || status() === "open") {
+            setStatus("closed");
+        }
+    };
+    const connect = () => {
+        var _a;
+        disconnect();
+        const target = typeof url === "function" ? url() : url;
+        const fetchImpl = fetchFn ?? (typeof fetch !== "undefined" ? fetch : null);
+        if (!fetchImpl) {
+            const err = new Error("createSSE: no fetch implementation available");
+            setError(err);
+            setStatus("error");
+            onError?.(err);
+            return;
+        }
+        controller = new AbortController();
+        const signal = controller.signal;
+        setError(null);
+        setStatus("connecting");
+        const resolvedHeaders = typeof headers === "function" ? headers() : (headers ?? {});
+        const init = { method, headers: resolvedHeaders, signal };
+        if (body !== undefined) {
+            init.body = typeof body === "string" ? body : JSON.stringify(body);
+            (_a = init.headers)["Content-Type"] ?? (_a["Content-Type"] = "application/json");
+        }
+        void (async () => {
+            try {
+                const response = await fetchImpl(target, init);
+                if (signal.aborted)
+                    return;
+                setStatus("open");
+                onOpen?.();
+                await pumpSSE(response, (ev) => {
+                    if (eventFilter && ev.event !== eventFilter)
+                        return;
+                    setEvents((prev) => [...prev, ev]);
+                    setLastEvent(ev);
+                    onEvent?.(ev);
+                }, signal);
+                if (signal.aborted)
+                    return;
+                setStatus("closed");
+                onDone?.();
+            }
+            catch (err) {
+                if (signal.aborted)
+                    return;
+                const e = err instanceof Error ? err : new Error(String(err));
+                setError(e);
+                setStatus("error");
+                onError?.(e);
+            }
+        })();
+    };
+    onCleanup(disconnect);
+    if (autoConnect && typeof window !== "undefined")
+        connect();
+    return { status, events, lastEvent, error, connect, disconnect };
+}
+let chatMessageCounter = 0;
+const nextMessageId = () => `msg_${++chatMessageCounter}_${Date.now()}`;
+const defaultBaseUrl = (kind) => {
+    if (kind === "anthropic")
+        return "https://api.anthropic.com";
+    if (kind === "meta")
+        return "https://api.llama.com/compat/v1";
+    return "https://api.openai.com/v1";
+};
+function buildBuiltinRequest(kind, options, history, signal, fetchImpl) {
+    const base = (options.baseUrl ?? defaultBaseUrl(kind)).replace(/\/$/, "");
+    const key = typeof options.apiKey === "function" ? options.apiKey() : options.apiKey;
+    const extraHeaders = options.headers ?? {};
+    const temperature = options.temperature;
+    const maxTokens = options.maxTokens ?? 1024;
+    if (kind === "anthropic") {
+        const systemText = options.system ??
+            history.find((m) => m.role === "system")?.content;
+        const apiMessages = history
+            .filter((m) => m.role !== "system")
+            .map((m) => ({ role: m.role, content: m.content }));
+        const init = {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...(key ? { "x-api-key": key } : {}),
+                "anthropic-version": "2023-06-01",
+                ...extraHeaders,
+            },
+            body: JSON.stringify({
+                model: options.model,
+                max_tokens: maxTokens,
+                ...(systemText ? { system: systemText } : {}),
+                ...(temperature !== undefined ? { temperature } : {}),
+                messages: apiMessages,
+                stream: true,
+            }),
+            signal,
+        };
+        return {
+            url: `${base}/v1/messages`,
+            init,
+            parseDelta: (data, event) => {
+                if (event === "message_stop")
+                    return { done: true };
+                if (event === "error") {
+                    let message = "Anthropic stream error";
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.error?.message)
+                            message = parsed.error.message;
+                    }
+                    catch {
+                        if (data.trim())
+                            message = `Anthropic stream error: ${data.slice(0, 200)}`;
+                    }
+                    throw new Error(message);
+                }
+                if (event !== "content_block_delta")
+                    return {};
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed.delta?.type === "text_delta" && parsed.delta.text) {
+                        return { text: parsed.delta.text };
+                    }
+                }
+                catch {
+                    // Ignore malformed delta payloads.
+                }
+                return {};
+            },
+        };
+    }
+    // openai + meta: OpenAI-compatible chat completions.
+    const init = {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            ...(key ? { Authorization: `Bearer ${key}` } : {}),
+            ...extraHeaders,
+        },
+        body: JSON.stringify({
+            model: options.model,
+            messages: [
+                ...(options.system
+                    ? [{ role: "system", content: options.system }]
+                    : history
+                        .filter((m) => m.role === "system")
+                        .map((m) => ({ role: m.role, content: m.content }))),
+                ...history
+                    .filter((m) => m.role !== "system")
+                    .map((m) => ({ role: m.role, content: m.content })),
+            ],
+            ...(temperature !== undefined ? { temperature } : {}),
+            stream: true,
+        }),
+        signal,
+    };
+    return {
+        url: `${base}/chat/completions`,
+        init,
+        parseDelta: (data) => {
+            if (data.trim() === "[DONE]")
+                return { done: true };
+            let parsed;
+            try {
+                parsed = JSON.parse(data);
+            }
+            catch {
+                return {}; // ignore malformed chunks
+            }
+            if (parsed.error?.message)
+                throw new Error(parsed.error.message);
+            const text = parsed.choices?.[0]?.delta?.content;
+            return text ? { text } : {};
+        },
+    };
+}
+/**
+ * Streaming chat over OpenAI, Anthropic, Meta (Llama API), or a
+ * custom provider.
+ *
+ * `send()` appends the user message, opens the provider stream, and
+ * appends text deltas to a live assistant message as they arrive, so
+ * UI bound to `messages()` renders the reply token by token. Pairs
+ * well with `createTyping` for a typewriter reveal.
+ *
+ * Keys stay in your hands: pass `apiKey` directly, or a function
+ * reading it from your own store. For production, prefer calling
+ * through your own server route and pointing `baseUrl` at it so
+ * keys never ship to the browser.
+ *
+ * SSR-safe: nothing connects until `send()` is called.
+ *
+ * ```ts
+ * const chat = createChatModel({
+ *   provider: "openai",
+ *   apiKey: () => localStorage.getItem("openai_key") ?? "",
+ *   model: "gpt-4o-mini",
+ *   system: "You are a concise assistant.",
+ *   onFinish: (msg) => console.log("done:", msg.content.length),
+ * });
+ * await chat.send("What is a signal?");
+ * ```
+ */
+export function createChatModel(options) {
+    const [messages, setMessages] = createSignal(options.system
+        ? [{ id: nextMessageId(), role: "system", content: options.system }]
+        : []);
+    const [streamingText, setStreamingText] = createSignal("");
+    const [status, setStatus] = createSignal("idle");
+    const [error, setError] = createSignal(null);
+    let controller = null;
+    const stop = () => {
+        controller?.abort();
+        controller = null;
+        if (status() === "streaming")
+            setStatus("idle");
+    };
+    const reset = () => {
+        stop();
+        setError(null);
+        setStreamingText("");
+        setMessages(options.system
+            ? [{ id: nextMessageId(), role: "system", content: options.system }]
+            : []);
+    };
+    const send = async (content) => {
+        if (status() === "streaming")
+            return;
+        const fetchImpl = options.fetchFn ??
+            (typeof fetch !== "undefined" ? fetch : null);
+        if (!fetchImpl) {
+            const err = new Error("createChatModel: no fetch implementation available");
+            setError(err);
+            setStatus("error");
+            options.onError?.(err);
+            return;
+        }
+        const userMessage = {
+            id: nextMessageId(),
+            role: "user",
+            content,
+        };
+        const assistantMessage = {
+            id: nextMessageId(),
+            role: "assistant",
+            content: "",
+        };
+        const history = [...messages(), userMessage];
+        setMessages([...history, assistantMessage]);
+        setStreamingText("");
+        setError(null);
+        setStatus("streaming");
+        controller = new AbortController();
+        const signal = controller.signal;
+        const assistantId = assistantMessage.id;
+        const appendText = (text) => {
+            setStreamingText((prev) => prev + text);
+            setMessages((prev) => prev.map((m) => m.id === assistantId ? { ...m, content: m.content + text } : m));
+        };
+        try {
+            let response;
+            let parseDelta;
+            const provider = options.provider;
+            if (typeof provider === "object" && provider.kind === "custom") {
+                response = await provider.stream(history, { signal, fetchFn: fetchImpl });
+                parseDelta = provider.parseDelta;
+            }
+            else {
+                const kind = provider;
+                const built = buildBuiltinRequest(kind, options, history, signal, fetchImpl);
+                parseDelta = built.parseDelta;
+                response = await fetchImpl(built.url, built.init);
+            }
+            if (signal.aborted)
+                return;
+            let finished = false;
+            await pumpSSE(response, (ev) => {
+                if (finished)
+                    return;
+                let parsed;
+                try {
+                    parsed = parseDelta(ev.data, ev.event);
+                }
+                catch (e) {
+                    throw e instanceof Error ? e : new Error(String(e));
+                }
+                if (parsed.text)
+                    appendText(parsed.text);
+                if (parsed.done)
+                    finished = true;
+            }, signal);
+            if (signal.aborted)
+                return;
+            setStatus("idle");
+            const final = messages().find((m) => m.id === assistantId);
+            if (final)
+                options.onFinish?.(final);
+        }
+        catch (err) {
+            if (signal.aborted) {
+                setStatus("idle");
+                return;
+            }
+            const e = err instanceof Error ? err : new Error(String(err));
+            setError(e);
+            setStatus("error");
+            options.onError?.(e);
+        }
+        finally {
+            controller = null;
+        }
+    };
+    onCleanup(stop);
+    return { messages, streamingText, status, error, send, stop, reset };
+}