@voybio/ace-swarm 0.1.0

package/dist/tui/layout.js

@@ -0,0 +1,367 @@
+/**
+ * ACE-TUI Layout Manager
+ *
+ * Screen zone management with dynamic resize handling.
+ * Arttime-inspired: defined zones for each UI element.
+ */
+import { getTermSize, write, writeAt, drawBox, clearRegion, cursor, screen, style, fg, bg, padRight, truncate, visibleWidth, box, symbols, formatTime, formatElapsed, formatNumber, hline, } from "./renderer.js";
+// ── Layout manager ───────────────────────────────────────────────────
+export class LayoutManager {
+    zones;
+    cols;
+    rows;
+    colorLevel;
+    tabs = [];
+    activeTab = 0;
+    constructor(colorLevel = "256") {
+        const size = getTermSize();
+        this.cols = size.cols;
+        this.rows = size.rows;
+        this.colorLevel = colorLevel;
+        this.computeZones();
+    }
+    /** Recalculate zones on terminal resize */
+    handleResize() {
+        const size = getTermSize();
+        this.cols = size.cols;
+        this.rows = size.rows;
+        this.computeZones();
+    }
+    computeZones() {
+        const inputHeight = 5;
+        const statusHeight = 1;
+        const mainHeight = Math.max(3, this.rows - 1 - statusHeight - inputHeight);
+        const statusY = 1 + mainHeight;
+        this.zones = {
+            tabBar: { x: 0, y: 0, width: this.cols, height: 1 },
+            main: { x: 0, y: 1, width: this.cols, height: mainHeight },
+            statusBar: { x: 0, y: statusY, width: this.cols, height: statusHeight },
+            inputLine: { x: 0, y: statusY + statusHeight, width: this.cols, height: inputHeight },
+        };
+    }
+    getZones() {
+        return this.zones;
+    }
+    getMainZone() {
+        return this.zones.main;
+    }
+    getCols() {
+        return this.cols;
+    }
+    getRows() {
+        return this.rows;
+    }
+    // ── Tab bar rendering ────────────────────────────────────────────
+    setTabs(tabs) {
+        this.tabs = tabs;
+    }
+    setActiveTab(index) {
+        this.activeTab = index;
+    }
+    getActiveTab() {
+        return this.activeTab;
+    }
+    renderTabBar() {
+        const { tabBar } = this.zones;
+        writeAt(tabBar.x, tabBar.y, bg.gray + " ".repeat(tabBar.width) + style.reset);
+        let x = 1;
+        for (let i = 0; i < this.tabs.length; i++) {
+            const tab = this.tabs[i];
+            const isActive = i === this.activeTab;
+            const label = ` ${tab.label} `;
+            const tabWidth = visibleWidth(label);
+            if (x + tabWidth >= tabBar.width - 2)
+                break;
+            if (isActive) {
+                writeAt(tabBar.x + x, tabBar.y, `${bg.black}${fg.brightWhite}${style.bold}${symbols.activeTab}${label}${style.reset}${bg.gray}`);
+            }
+            else {
+                const actColor = tab.hasActivity ? fg.brightYellow : fg.white;
+                writeAt(tabBar.x + x, tabBar.y, `${bg.gray}${actColor}${symbols.tab}${label}${style.reset}${bg.gray}`);
+            }
+            x += tabWidth + 2;
+        }
+        // [+] new tab indicator
+        if (x + 3 < tabBar.width) {
+            writeAt(tabBar.x + x, tabBar.y, `${bg.gray}${fg.gray} [+]${style.reset}`);
+        }
+        // Title on right
+        const title = "ACE Swarm TUI";
+        if (x + visibleWidth(title) + 2 < tabBar.width) {
+            writeAt(tabBar.x + tabBar.width - title.length - 2, tabBar.y, `${bg.gray}${fg.brightCyan}${title} ${style.reset}`);
+        }
+    }
+    // ── Status bar rendering (arttime contextual time bar pattern) ───
+    renderStatusBar(state) {
+        const { statusBar } = this.zones;
+        const y = statusBar.y;
+        // Separator line
+        writeAt(0, y - 1, `${fg.gray}${box.horizontal.repeat(this.cols)}${style.reset}`);
+        // Build status segments
+        const elapsed = formatElapsed(Date.now() - state.startTime);
+        const time = formatTime();
+        // State indicator with color
+        let stateIndicator;
+        switch (state.taskState) {
+            case "idle":
+                stateIndicator = `${fg.gray}${symbols.hollowBullet} idle${style.reset}`;
+                break;
+            case "running":
+                stateIndicator = `${fg.green}${symbols.bullet} running${style.reset}`;
+                break;
+            case "blocked":
+                stateIndicator = `${fg.yellow}${symbols.bullet} blocked${style.reset}`;
+                break;
+            case "overdue":
+                stateIndicator = `${fg.red}${style.bold}${symbols.bullet} OVERDUE${style.reset}`;
+                break;
+        }
+        const providerSeg = `${fg.cyan}provider: ${fg.brightCyan}${state.provider}${style.reset}`;
+        const modelSeg = `${fg.cyan}model: ${fg.brightCyan}${state.model}${style.reset}`;
+        const tokenSeg = `${fg.gray}tokens: ${fg.white}${formatNumber(state.tokensIn)}/${formatNumber(state.tokensOut)}${style.reset}`;
+        const timeSeg = `${fg.gray}${elapsed}${style.reset}`;
+        const clockSeg = `${fg.gray}${style.underline}${time}${style.reset}`;
+        const segments = [stateIndicator, providerSeg, modelSeg, tokenSeg, timeSeg, clockSeg];
+        const sep = ` ${fg.gray}│${style.reset} `;
+        const line = ` ${segments.join(sep)} `;
+        // Clear and write
+        writeAt(statusBar.x, y, bg.black + " ".repeat(this.cols) + style.reset);
+        writeAt(statusBar.x, y, line);
+    }
+    // ── Input line rendering ─────────────────────────────────────────
+    renderInputLine(buffer, cursorPos, mode, prompt) {
+        const { inputLine } = this.zones;
+        const y = inputLine.y;
+        const width = Math.max(1, this.cols - 1);
+        const textRows = Math.max(1, inputLine.height - 1);
+        // Separator
+        writeAt(0, y, `${fg.gray}${box.horizontal.repeat(this.cols)}${style.reset}`);
+        // Prompt and multi-line wrapped input.
+        const promptText = prompt ?? (mode === "command" ? "" : mode === "chat" ? "> " : "> ");
+        const content = `${promptText}${buffer}`;
+        const wrapped = this.wrapInputText(content, width);
+        const start = Math.max(0, wrapped.length - textRows);
+        const visible = wrapped.slice(start);
+        for (let row = 0; row < textRows; row++) {
+            const line = visible[row] ?? "";
+            const lineY = y + 1 + row;
+            writeAt(inputLine.x, lineY, " ".repeat(this.cols));
+            if (row === 0 && start === 0 && promptText.length > 0) {
+                const plain = line.startsWith(promptText) ? line.slice(promptText.length) : line;
+                writeAt(inputLine.x, lineY, `${fg.gray}${promptText}${style.reset}${plain}`);
+            }
+            else {
+                writeAt(inputLine.x, lineY, line);
+            }
+        }
+        // Position cursor
+        const absoluteCursor = Math.max(0, Math.min(content.length, promptText.length + cursorPos));
+        const cursorLine = Math.floor(absoluteCursor / width);
+        const cursorCol = absoluteCursor % width;
+        const visibleCursorLine = Math.max(0, Math.min(textRows - 1, cursorLine - start));
+        const cx = inputLine.x + cursorCol;
+        const cy = y + 1 + visibleCursorLine;
+        write(cursor.to(cx, cy) + cursor.show);
+    }
+    // ── Dashboard panels ─────────────────────────────────────────────
+    renderDashboard(data, controls) {
+        const main = this.zones.main;
+        // Clear main area
+        clearRegion(main.x, main.y, main.width, main.height);
+        // Control strip at top of dashboard.
+        writeAt(main.x, main.y, `${bg.black}${" ".repeat(main.width)}${style.reset}`);
+        if (controls) {
+            this.renderControlStrip(main.x + 1, main.y, main.width - 2, controls);
+        }
+        const content = {
+            x: main.x,
+            y: main.y + 1,
+            width: main.width,
+            height: Math.max(4, main.height - 1),
+        };
+        const midX = Math.floor(content.width / 2);
+        // Status panel (top-left)
+        const statusH = Math.max(2, Math.min(8, content.height - 3));
+        const statusW = midX - 1;
+        drawBox(content.x, content.y, statusW, statusH, { title: "Status", titleColor: fg.brightCyan, borderColor: fg.gray, rounded: true });
+        this.renderStatusPanel(content.x + 2, content.y + 1, statusW - 4, statusH - 2, data);
+        // Tasks panel (top-right)
+        const tasksW = content.width - midX - 1;
+        drawBox(content.x + midX + 1, content.y, tasksW, statusH, { title: "Tasks", titleColor: fg.brightYellow, borderColor: fg.gray, rounded: true });
+        this.renderTasksPanel(content.x + midX + 3, content.y + 1, tasksW - 4, statusH - 2, data.tasks);
+        // Activity log (bottom)
+        const actY = content.y + statusH + 1;
+        const actH = Math.max(2, content.height - statusH - 1);
+        drawBox(content.x, actY, content.width, actH, { title: "Agent Activity", titleColor: fg.brightGreen, borderColor: fg.gray, rounded: true });
+        this.renderActivityLog(content.x + 2, actY + 1, content.width - 4, actH - 2, data.events);
+    }
+    renderStatusPanel(x, y, w, h, data) {
+        const lines = [
+            `${fg.gray}Phase:   ${fg.brightWhite}${data.phase}`,
+            `${fg.gray}Provider:${fg.brightCyan} ${padRight(data.provider, 8)}`,
+            `${fg.gray}Model:   ${fg.brightCyan}${data.model}`,
+            `${fg.gray}Agents:  ${fg.brightGreen}${data.activeAgents}${fg.gray}/${data.totalAgents} active`,
+            `${fg.gray}Uptime:  ${fg.white}${formatElapsed(Date.now() - data.startTime)}`,
+            `${fg.gray}Tokens:  ${fg.white}${formatNumber(data.tokensIn)} in / ${formatNumber(data.tokensOut)} out`,
+            `${fg.gray}Speed:   ${fg.white}${data.tokensPerSec.toFixed(0)} tok/s`,
+        ];
+        for (let i = 0; i < Math.min(lines.length, h); i++) {
+            writeAt(x, y + i, truncate(lines[i] + style.reset, w));
+        }
+    }
+    renderControlStrip(x, y, w, controls) {
+        let cursorX = x;
+        for (let i = 0; i < controls.items.length; i++) {
+            const item = controls.items[i];
+            const active = controls.focused && i === controls.selectedIndex;
+            const seg = `${item.label}: ${item.value}`;
+            const styled = active
+                ? `${bg.brightBlue}${fg.brightWhite}${style.bold} ${seg} ${style.reset}`
+                : `${bg.black}${fg.gray} ${seg} ${style.reset}`;
+            const segW = visibleWidth(seg) + 2;
+            if (cursorX + segW > x + w)
+                break;
+            writeAt(cursorX, y, styled);
+            cursorX += segW + 1;
+        }
+    }
+    renderTasksPanel(x, y, w, h, tasks) {
+        for (let i = 0; i < Math.min(tasks.length, h); i++) {
+            const t = tasks[i];
+            const icon = t.done ? `${fg.green}${symbols.check}` : `${fg.gray}${symbols.hollowBullet}`;
+            const priority = t.priority ? `${fg.gray}[${t.priority}]` : "";
+            const line = `${icon} ${fg.white}${t.title} ${priority}${style.reset}`;
+            writeAt(x, y + i, truncate(line, w));
+        }
+        if (tasks.length === 0) {
+            writeAt(x, y, `${fg.gray}No tasks${style.reset}`);
+        }
+    }
+    renderActivityLog(x, y, w, h, events) {
+        const visible = events.slice(-h);
+        for (let i = 0; i < visible.length; i++) {
+            const e = visible[i];
+            const timeStr = formatTime(new Date(e.timestamp));
+            const roleColor = this.agentColor(e.agent);
+            const line = `${fg.gray}${timeStr} ${roleColor}[${e.agent}]${style.reset} ${e.message}`;
+            writeAt(x, y + i, truncate(line, w));
+        }
+        if (events.length === 0) {
+            writeAt(x, y, `${fg.gray}No activity yet${style.reset}`);
+        }
+    }
+    // ── Chat view rendering ──────────────────────────────────────────
+    renderChatView(messages) {
+        const main = this.zones.main;
+        clearRegion(main.x, main.y, main.width, main.height);
+        const maxVisible = main.height - 1;
+        const visible = messages.slice(-maxVisible);
+        for (let i = 0; i < visible.length; i++) {
+            const msg = visible[i];
+            const y = main.y + i;
+            if (msg.role === "user") {
+                const prefix = `${fg.brightCyan}${style.bold}You: ${style.reset}`;
+                writeAt(main.x + 1, y, truncate(`${prefix}${msg.content}`, main.width - 2));
+            }
+            else if (msg.role === "assistant") {
+                const prefix = `${fg.brightGreen}${style.bold}AI:  ${style.reset}`;
+                // Wrap long assistant messages
+                const lines = this.wrapText(msg.content, main.width - 7);
+                for (let j = 0; j < lines.length && (i + j) < maxVisible; j++) {
+                    const p = j === 0 ? prefix : "     ";
+                    writeAt(main.x + 1, y + j, truncate(`${p}${lines[j]}`, main.width - 2));
+                    if (j > 0)
+                        i++;
+                }
+            }
+            else if (msg.role === "system") {
+                writeAt(main.x + 1, y, truncate(`${fg.gray}${style.italic}${msg.content}${style.reset}`, main.width - 2));
+            }
+        }
+    }
+    /** Render streaming text at the bottom of chat */
+    renderStreamChunk(text, line) {
+        const main = this.zones.main;
+        const y = main.y + Math.min(line, main.height - 2);
+        writeAt(main.x + 6, y, truncate(text, main.width - 8));
+    }
+    // ── Agent tab view ───────────────────────────────────────────────
+    renderAgentView(agentName, output, thinking) {
+        const main = this.zones.main;
+        clearRegion(main.x, main.y, main.width, main.height);
+        // Agent header
+        const headerColor = this.agentColor(agentName);
+        writeAt(main.x + 1, main.y, `${headerColor}${style.bold}Agent: ${agentName}${style.reset}`);
+        hline(main.x, main.y + 1, main.width, box.horizontal);
+        // Output area
+        const outputStart = main.y + 2;
+        const thinkingHeight = thinking ? 4 : 0;
+        const outputHeight = main.height - 3 - thinkingHeight;
+        const visible = output.slice(-outputHeight);
+        for (let i = 0; i < visible.length; i++) {
+            writeAt(main.x + 1, outputStart + i, truncate(visible[i], main.width - 2));
+        }
+        // Thinking panel (if active)
+        if (thinking) {
+            const thinkY = main.y + main.height - thinkingHeight;
+            drawBox(main.x, thinkY, main.width, thinkingHeight, { title: "Thinking", titleColor: fg.brightMagenta, borderColor: fg.gray, rounded: true });
+            const thinkLines = this.wrapText(thinking, main.width - 4);
+            for (let i = 0; i < Math.min(thinkLines.length, thinkingHeight - 2); i++) {
+                writeAt(main.x + 2, thinkY + 1 + i, `${fg.gray}${style.italic}${truncate(thinkLines[i], main.width - 4)}${style.reset}`);
+            }
+        }
+    }
+    // ── Utilities ────────────────────────────────────────────────────
+    agentColor(name) {
+        const colors = [fg.brightCyan, fg.brightGreen, fg.brightYellow, fg.brightMagenta, fg.brightBlue, fg.brightRed];
+        let hash = 0;
+        for (const ch of name)
+            hash = (hash * 31 + ch.charCodeAt(0)) | 0;
+        return colors[Math.abs(hash) % colors.length];
+    }
+    wrapText(text, width) {
+        const lines = [];
+        const words = text.split(" ");
+        let current = "";
+        for (const word of words) {
+            if (current.length + word.length + 1 > width) {
+                if (current)
+                    lines.push(current);
+                current = word;
+            }
+            else {
+                current = current ? current + " " + word : word;
+            }
+        }
+        if (current)
+            lines.push(current);
+        return lines.length ? lines : [""];
+    }
+    wrapInputText(text, width) {
+        if (!text)
+            return [""];
+        const chunks = [];
+        for (let i = 0; i < text.length; i += width) {
+            chunks.push(text.slice(i, i + width));
+        }
+        return chunks.length > 0 ? chunks : [""];
+    }
+    /** Full screen initialization */
+    initScreen() {
+        write(screen.altBuffer);
+        write(cursor.hide);
+        write(screen.clear);
+        write(cursor.home);
+    }
+    /** Full screen teardown */
+    destroyScreen() {
+        write(cursor.show);
+        write(screen.mainBuffer);
+    }
+    /** Full redraw (arttime: called on resume from suspend) */
+    fullRedraw() {
+        write(screen.clear);
+        this.handleResize();
+    }
+}
+//# sourceMappingURL=layout.js.map

package/dist/tui/ollama.d.ts

@@ -0,0 +1,116 @@
+/**
+ * ACE-TUI Ollama Client
+ *
+ * Direct HTTP communication with Ollama API.
+ * Zero dependencies — uses Node.js built-in fetch/http.
+ * Supports model listing, pulling, chat streaming, and health checks.
+ */
+export interface OllamaModel {
+    name: string;
+    size: number;
+    digest: string;
+    modified_at: string;
+    details?: {
+        format?: string;
+        family?: string;
+        parameter_size?: string;
+        quantization_level?: string;
+    };
+}
+export interface OllamaModelInfo {
+    modelfile: string;
+    parameters: string;
+    template: string;
+    details: {
+        format: string;
+        family: string;
+        parameter_size: string;
+        quantization_level: string;
+    };
+}
+export interface ChatMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface ChatRequest {
+    model: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    options?: {
+        temperature?: number;
+        top_p?: number;
+        num_ctx?: number;
+        num_predict?: number;
+        stop?: string[];
+    };
+}
+export interface ChatChunk {
+    model: string;
+    message: {
+        role: string;
+        content: string;
+    };
+    done: boolean;
+    total_duration?: number;
+    load_duration?: number;
+    prompt_eval_count?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export interface GenerateRequest {
+    model: string;
+    prompt: string;
+    system?: string;
+    stream?: boolean;
+    options?: {
+        temperature?: number;
+        top_p?: number;
+        num_ctx?: number;
+        num_predict?: number;
+    };
+}
+export interface GenerateChunk {
+    model: string;
+    response: string;
+    done: boolean;
+    total_duration?: number;
+    prompt_eval_count?: number;
+    eval_count?: number;
+    eval_duration?: number;
+}
+export interface PullProgress {
+    status: string;
+    digest?: string;
+    total?: number;
+    completed?: number;
+}
+export declare class OllamaClient {
+    private baseUrl;
+    private abortControllers;
+    constructor(baseUrl?: string);
+    getBaseUrl(): string;
+    setBaseUrl(url: string): void;
+    /** Check if Ollama is reachable */
+    isReachable(): Promise<boolean>;
+    /** List available models */
+    listModels(): Promise<OllamaModel[]>;
+    /** Get model info */
+    showModel(name: string): Promise<OllamaModelInfo>;
+    /** Pull a model with progress streaming */
+    pullModel(name: string): AsyncGenerator<PullProgress>;
+    /** Chat with streaming response */
+    chat(request: ChatRequest): AsyncGenerator<ChatChunk>;
+    /** Generate (completion) with streaming */
+    generate(request: GenerateRequest): AsyncGenerator<GenerateChunk>;
+    /** Abort a running operation */
+    abort(key?: string): void;
+    private fetch;
+    /** Stream newline-delimited JSON from a ReadableStream */
+    private streamJsonLines;
+}
+export declare class OllamaError extends Error {
+    statusCode: number;
+    responseBody: string;
+    constructor(message: string, statusCode: number, responseBody: string);
+}
+//# sourceMappingURL=ollama.d.ts.map

package/dist/tui/ollama.js

@@ -0,0 +1,192 @@
+/**
+ * ACE-TUI Ollama Client
+ *
+ * Direct HTTP communication with Ollama API.
+ * Zero dependencies — uses Node.js built-in fetch/http.
+ * Supports model listing, pulling, chat streaming, and health checks.
+ */
+// ── Client ───────────────────────────────────────────────────────────
+export class OllamaClient {
+    baseUrl;
+    abortControllers = new Map();
+    constructor(baseUrl) {
+        this.baseUrl = (baseUrl ?? "").replace(/\/$/, "");
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    setBaseUrl(url) {
+        this.baseUrl = url.replace(/\/$/, "");
+    }
+    /** Check if Ollama is reachable */
+    async isReachable() {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            const res = await fetch(`${this.baseUrl}/api/tags`, {
+                signal: controller.signal,
+            });
+            clearTimeout(timeout);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** List available models */
+    async listModels() {
+        const res = await this.fetch("/api/tags");
+        const data = (await res.json());
+        return data.models ?? [];
+    }
+    /** Get model info */
+    async showModel(name) {
+        const res = await this.fetch("/api/show", {
+            method: "POST",
+            body: JSON.stringify({ name }),
+        });
+        return (await res.json());
+    }
+    /** Pull a model with progress streaming */
+    async *pullModel(name) {
+        const key = `pull:${name}`;
+        const controller = new AbortController();
+        this.abortControllers.set(key, controller);
+        try {
+            const res = await this.fetch("/api/pull", {
+                method: "POST",
+                body: JSON.stringify({ name, stream: true }),
+                signal: controller.signal,
+            });
+            if (!res.body)
+                throw new Error("No response body");
+            yield* this.streamJsonLines(res.body);
+        }
+        finally {
+            this.abortControllers.delete(key);
+        }
+    }
+    /** Chat with streaming response */
+    async *chat(request) {
+        const key = `chat:${Date.now()}`;
+        const controller = new AbortController();
+        this.abortControllers.set(key, controller);
+        try {
+            const res = await this.fetch("/api/chat", {
+                method: "POST",
+                body: JSON.stringify({ ...request, stream: true }),
+                signal: controller.signal,
+            });
+            if (!res.body)
+                throw new Error("No response body");
+            yield* this.streamJsonLines(res.body);
+        }
+        finally {
+            this.abortControllers.delete(key);
+        }
+    }
+    /** Generate (completion) with streaming */
+    async *generate(request) {
+        const key = `gen:${Date.now()}`;
+        const controller = new AbortController();
+        this.abortControllers.set(key, controller);
+        try {
+            const res = await this.fetch("/api/generate", {
+                method: "POST",
+                body: JSON.stringify({ ...request, stream: true }),
+                signal: controller.signal,
+            });
+            if (!res.body)
+                throw new Error("No response body");
+            yield* this.streamJsonLines(res.body);
+        }
+        finally {
+            this.abortControllers.delete(key);
+        }
+    }
+    /** Abort a running operation */
+    abort(key) {
+        if (key) {
+            this.abortControllers.get(key)?.abort();
+            this.abortControllers.delete(key);
+        }
+        else {
+            // Abort all
+            for (const [k, c] of this.abortControllers) {
+                c.abort();
+                this.abortControllers.delete(k);
+            }
+        }
+    }
+    // ── Internal helpers ─────────────────────────────────────────────
+    async fetch(path, options) {
+        if (!this.baseUrl) {
+            throw new OllamaError("Ollama base URL is not configured. Set one explicitly or run `ace doctor --scan`.", 0, "");
+        }
+        const url = `${this.baseUrl}${path}`;
+        const res = await fetch(url, {
+            ...options,
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+                ...(options?.headers ?? {}),
+            },
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new OllamaError(`Ollama API error: ${res.status} ${res.statusText}`, res.status, text);
+        }
+        return res;
+    }
+    /** Stream newline-delimited JSON from a ReadableStream */
+    async *streamJsonLines(body) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    try {
+                        yield JSON.parse(trimmed);
+                    }
+                    catch {
+                        // Skip malformed JSON lines
+                    }
+                }
+            }
+            // Process remaining buffer
+            if (buffer.trim()) {
+                try {
+                    yield JSON.parse(buffer.trim());
+                }
+                catch {
+                    // Skip
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+// ── Error class ──────────────────────────────────────────────────────
+export class OllamaError extends Error {
+    statusCode;
+    responseBody;
+    constructor(message, statusCode, responseBody) {
+        super(message);
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+        this.name = "OllamaError";
+    }
+}
+//# sourceMappingURL=ollama.js.map