klyro 0.1.4 → 0.1.6

package/dist/agent/runtime.js

@@ -17,6 +17,10 @@
 import { text, toolUse, toolResult as mkToolResult } from './message.js';
 import { redact } from '../policy/secret-redactor.js';
 import { RuntimeTelemetry, emptyTelemetryBlock, summarizeToolCall } from '../context/level7.js';
+import { verify, diagnosticForModel } from '../verification/engine.js';
+import { detectVerifyCommand } from '../verification/auto.js';
+import { globalBus } from '../events/bus.js';
+import { TraceWriter } from '../trace/writer.js';
 const DEFAULT_MAX_STEPS = 30;
 /** Convert a registry of tools into ToolDefinitions for the provider. */
 export function toolDefinitions(registry) {
@@ -28,22 +32,94 @@ export function toolDefinitions(registry) {
 }
 /** Run the autonomous loop. */
 export async function run(opts, deps) {
-    const maxSteps = opts.maxSteps ?? DEFAULT_MAX_STEPS;
-    const transcript = opts.initialTranscript
-        ? [...opts.initialTranscript, { role: 'user', content: [text(opts.task)] }]
-        : [{ role: 'user', content: [text(opts.task)] }];
+    const maxSteps = opts.maxTurns ?? opts.maxSteps ?? DEFAULT_MAX_STEPS;
+    const transcript = (() => {
+        if (opts.initialTranscript) {
+            const base = [...opts.initialTranscript];
+            // Avoid duplicating task when resuming a session that already ends with same task
+            const last = base[base.length - 1];
+            if (last?.role === 'user') {
+                const lastText = last.content
+                    .filter((b) => b.kind === 'text')
+                    .map((b) => b.text ?? '')
+                    .join('');
+                if (lastText === opts.task)
+                    return base;
+            }
+            return [...base, { role: 'user', content: [text(opts.task)] }];
+        }
+        return [{ role: 'user', content: [text(opts.task)] }];
+    })();
     const usage = { input: 0, output: 0 };
     let steps = 0;
     let toolCallCount = 0;
     let finalText = '';
     let repairs = 0;
+    let verificationAttempts = 0;
+    let hasEdits = false;
     const emit = opts.onEvent;
     const telemetry = new RuntimeTelemetry();
     telemetry.setMaxSteps(maxSteps);
+    // 3.1 — Event bus + TraceWriter
+    const bus = deps.bus ?? globalBus;
+    let tracer;
+    if (opts.persist?.sessionId) {
+        tracer = new TraceWriter(opts.persist.sessionId);
+        await tracer.init().catch(() => undefined);
+    }
+    const emitKlyro = (ev) => {
+        bus.emit(ev);
+        tracer?.write(ev).catch(() => undefined);
+    };
+    const closeTracer = async () => {
+        try {
+            await tracer?.close();
+        }
+        catch { /* ignore */ }
+    };
+    // Level 9 — persistence helpers
+    const store = opts.persist?.store;
+    const sessionId = opts.persist?.sessionId;
+    async function checkpoint(msg, obs) {
+        if (!store || !sessionId)
+            return;
+        try {
+            if (msg) {
+                await store.appendMessage(sessionId, { role: msg.role, content: msg.content, ts: Date.now() });
+            }
+            if (obs) {
+                await store.appendObservation(sessionId, {
+                    toolCallId: obs.toolCallId,
+                    toolName: obs.toolName,
+                    input: obs.input,
+                    output: obs.output,
+                    isError: obs.isError,
+                    startedAt: Date.now(),
+                    finishedAt: Date.now(),
+                });
+            }
+            emit?.({ kind: 'checkpoint_saved', sessionId });
+        }
+        catch {
+            // best-effort — don't crash runtime on persistence failure
+        }
+    }
+    // Persist initial user message
+    if (store && sessionId && transcript.length > 0) {
+        // Fire-and-forget initial checkpoint (don't await to block loop start)
+        void checkpoint(transcript[transcript.length - 1]);
+    }
     outer: while (steps < maxSteps) {
         if (opts.signal?.aborted) {
             emit?.({ kind: 'aborted' });
-            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs };
+            if (store && sessionId) {
+                try {
+                    await store.setStatus(sessionId, 'aborted', finalText);
+                }
+                catch { /* ignore */ }
+            }
+            await closeTracer();
+            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined };
         }
         steps++;
         emit?.({ kind: 'step_start', step: steps });
@@ -92,6 +168,13 @@ export async function run(opts, deps) {
             }
             else if (ev.kind === 'error') {
                 telemetry.recordError(`stream_error: ${ev.code}`);
+                if (store && sessionId) {
+                    try {
+                        await store.setStatus(sessionId, 'aborted', textBuf);
+                    }
+                    catch { /* ignore */ }
+                }
+                await closeTracer();
                 return {
                     status: 'no_final',
                     steps,
@@ -99,6 +182,8 @@ export async function run(opts, deps) {
                     finalText: textBuf,
                     transcript,
                     usage,
+                    repairs,
+                    verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined,
                 };
             }
         }
@@ -119,91 +204,219 @@ export async function run(opts, deps) {
             assistantContent.push(toolUse(tc.id, tc.name, input));
             emit?.({ kind: 'tool_call_end', id: tc.id, name: tc.name, input });
         }
-        transcript.push({ role: 'assistant', content: assistantContent });
-        // No tool calls → done.
+        const assistantMsg = { role: 'assistant', content: assistantContent };
+        transcript.push(assistantMsg);
+        await checkpoint(assistantMsg);
+        // No tool calls → potential completion (Level 8 verify gate)
         if (opts.signal?.aborted) {
             finalText = textBuf;
             emit?.({ kind: 'aborted' });
-            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs };
+            if (store && sessionId) {
+                try {
+                    await store.setStatus(sessionId, 'aborted', finalText);
+                }
+                catch { /* ignore */ }
+            }
+            await closeTracer();
+            return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined };
         }
         if (finalizedCalls.length === 0) {
             finalText = textBuf;
+            // Level 8 — Verification + Autonomous Repair
+            const verifyEnabled = opts.verify?.enabled !== false;
+            const verifyCmd = opts.verify?.command ?? detectVerifyCommand(opts.cwd);
+            const maxRepairs = opts.verify?.maxRepairAttempts ?? 3;
+            if (verifyEnabled && hasEdits && verifyCmd && verificationAttempts < maxRepairs) {
+                emit?.({ kind: 'verification_started', command: verifyCmd });
+                let vResult;
+                try {
+                    vResult = await verify({ cwd: opts.cwd, command: verifyCmd, timeoutMs: opts.verify?.timeoutMs });
+                }
+                catch (e) {
+                    const msg = e instanceof Error ? e.message : String(e);
+                    vResult = { ok: false, exitCode: -1, stdout: '', stderr: msg, failure: { type: 'unknown', files: [], raw: msg, exitCode: -1 } };
+                }
+                if (vResult.ok) {
+                    emit?.({ kind: 'verification_succeeded', command: verifyCmd });
+                    emit?.({ kind: 'final_text', text: finalText });
+                    emit?.({ kind: 'step_end', step: steps });
+                    if (store && sessionId) {
+                        try {
+                            await store.setStatus(sessionId, 'complete', finalText);
+                        }
+                        catch { /* ignore */ }
+                    }
+                    await closeTracer();
+                    return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: true, command: verifyCmd, attempts: verificationAttempts } };
+                }
+                // Failure → repair loop
+                verificationAttempts++;
+                const diagnostic = diagnosticForModel(vResult);
+                const failureType = vResult.failure?.type ?? 'unknown';
+                emit?.({ kind: 'verification_failed', step: String(steps), reason: diagnostic.slice(0, 800) });
+                emit?.({ kind: 'repair_started', attempt: verificationAttempts, maxAttempts: maxRepairs, reason: diagnostic.slice(0, 400) });
+                telemetry.recordError(`verify_${failureType}`);
+                const repairMsg = {
+                    role: 'user',
+                    content: [text(`Verification failed (attempt ${verificationAttempts}/${maxRepairs}) running \`${verifyCmd}\`:\n\n${diagnostic}\n\nPlease analyze the failure, re-read the failing files, and repair the code. Focus on the error above.`)],
+                };
+                transcript.push(repairMsg);
+                await checkpoint(repairMsg);
+                if (store && sessionId) {
+                    try {
+                        await store.setStatus(sessionId, 'verify_failed', finalText);
+                    }
+                    catch { /* ignore */ }
+                }
+                if (verificationAttempts >= maxRepairs) {
+                    emit?.({ kind: 'final_text', text: finalText });
+                    emit?.({ kind: 'step_end', step: steps });
+                    await closeTracer();
+                    return { status: 'verify_failed', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: { ok: false, command: verifyCmd, attempts: verificationAttempts, failureType } };
+                }
+                emit?.({ kind: 'step_end', step: steps });
+                continue; // -> next iteration lets model repair
+            }
             emit?.({ kind: 'final_text', text: finalText });
             emit?.({ kind: 'step_end', step: steps });
-            return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs };
+            if (store && sessionId) {
+                try {
+                    await store.setStatus(sessionId, 'complete', finalText);
+                }
+                catch { /* ignore */ }
+            }
+            await closeTracer();
+            return { status: 'complete', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: true, attempts: verificationAttempts } : undefined };
         }
-        // Execute each tool call (after policy).
+        // 3.1 — emit turn events
+        emitKlyro({ type: 'turn.start', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', turn: steps, model: opts.model });
+        // Execute each tool call (after policy) — 3.5 parallel if all concurrencySafe
         const toolCtx = {
             cwd: opts.cwd,
             env: process.env,
             signal: opts.signal,
             nonInteractive: opts.nonInteractive,
+            sessionId,
         };
-        for (const call of finalizedCalls) {
-            toolCallCount++;
+        const allSafe = finalizedCalls.length > 1 && finalizedCalls.every((c) => deps.registry.get(c.name)?.isConcurrencySafe !== false);
+        const runOne = async (call) => {
+            // Use per-call handling without continue (runOne is not a loop)
             const decision = await deps.policy.evaluate({ name: call.name, input: call.input }, { cwd: opts.cwd, nonInteractive: opts.nonInteractive });
             emit?.({ kind: 'policy_decision', id: call.id, name: call.name, action: decision.action, ...(decision.action !== 'allow' ? { reason: decision.reason } : {}) });
+            // Mirror to KlyroEvent bus
+            emitKlyro({ type: 'permission.decision', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', callId: call.id, action: decision.action, ...(decision.action !== 'allow' ? { reason: decision.reason } : {}) });
             if (decision.action === 'deny') {
-                transcript.push({
+                const denyMsg = {
                     role: 'tool',
                     content: [
                         mkToolResult(call.id, call.name, { error: 'POLICY_DENIED', reason: decision.reason }, true),
                     ],
-                });
+                };
+                transcript.push(denyMsg);
+                await checkpoint(denyMsg, { toolCallId: call.id, toolName: call.name, input: call.input, output: { error: 'POLICY_DENIED', reason: decision.reason }, isError: true });
+                emitKlyro({ type: 'tool.result', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', callId: call.id, name: call.name, output: { error: 'POLICY_DENIED' }, isError: true, latencyMs: 0 });
                 telemetry.recordToolError(call, 'policy_denied');
                 emit?.({ kind: 'tool_result', id: call.id, name: call.name, output: { error: 'POLICY_DENIED', reason: decision.reason }, isError: true, latencyMs: 0 });
-                continue;
+                return;
             }
             if (decision.action === 'ask') {
+                emitKlyro({ type: 'permission.ask', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', callId: call.id, name: call.name, reason: decision.reason });
                 const choice = await deps.approval.ask({
                     toolName: call.name,
                     reason: decision.reason,
                     summary: summarizeToolCall(call),
                 });
+                // Approval UI in TUI handles y/a/A/n/e/? — e edits input, ? explains
                 if (choice === 'deny') {
-                    transcript.push({
+                    const denyMsg2 = {
                         role: 'tool',
                         content: [
                             mkToolResult(call.id, call.name, { error: 'POLICY_DENIED', reason: 'user denied' }, true),
                         ],
-                    });
+                    };
+                    transcript.push(denyMsg2);
+                    await checkpoint(denyMsg2, { toolCallId: call.id, toolName: call.name, input: call.input, output: { error: 'POLICY_DENIED', reason: 'user denied' }, isError: true });
                     telemetry.recordToolError(call, 'user_denied');
                     emit?.({ kind: 'tool_result', id: call.id, name: call.name, output: { error: 'POLICY_DENIED', reason: 'user denied' }, isError: true, latencyMs: 0 });
-                    continue;
+                    return;
                 }
+                // Handle 'edit' choice: for now treat as allow with edited input (future: re-prompt)
                 repairs++;
             }
             const t0 = Date.now();
+            emitKlyro({ type: 'tool.call', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', callId: call.id, name: call.name, input: call.input });
             const obs = await deps.registry.execute(call.name, call.input, toolCtx);
             const latencyMs = Date.now() - t0;
             const output = obs.ok ? redactOutput(obs.value) : redactOutput({ error: obs.error });
-            transcript.push({
+            const toolMsg = {
                 role: 'tool',
                 content: [mkToolResult(call.id, call.name, output, !obs.ok)],
-            });
+            };
+            transcript.push(toolMsg);
+            await checkpoint(toolMsg, { toolCallId: call.id, toolName: call.name, input: call.input, output, isError: !obs.ok });
             if (obs.ok) {
                 telemetry.recordToolCall(call, latencyMs, false);
+                if (call.name === 'write_file' || call.name === 'edit_file')
+                    hasEdits = true;
             }
             else {
                 const code = String(obs.error?.code ?? 'tool_error');
                 telemetry.recordToolCall(call, latencyMs, true);
                 telemetry.recordError(`${code}: ${call.name}`);
             }
+            emitKlyro({ type: 'tool.result', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', callId: call.id, name: call.name, output, isError: !obs.ok, latencyMs });
             emit?.({ kind: 'tool_result', id: call.id, name: call.name, output, isError: !obs.ok, latencyMs });
             if (obs.ok) {
                 const fileChanged = inferFileChanged(call.name, call.input, obs.value);
-                if (fileChanged)
+                if (fileChanged) {
                     emit?.({ kind: 'file_changed', path: fileChanged.path, op: fileChanged.op });
+                    emitKlyro({ type: 'file.changed', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', path: fileChanged.path, op: fileChanged.op });
+                }
+            }
+        };
+        // 3.5 — parallel if all concurrencySafe, sequential otherwise
+        if (allSafe) {
+            await Promise.all(finalizedCalls.map((c) => { toolCallCount++; return runOne(c); }));
+        }
+        else {
+            for (const call of finalizedCalls) {
+                toolCallCount++;
+                await runOne(call);
+                // 3.5 — cancellation: if signal aborted mid-tools, stop
+                if (opts.signal?.aborted)
+                    break;
             }
         }
         emit?.({ kind: 'step_end', step: steps });
+        emitKlyro({ type: 'turn.end', ts: Date.now(), sessionId: sessionId ?? 'ephemeral', turn: steps });
+        // Level 9 — checkpoint status after each step
+        if (store && sessionId) {
+            try {
+                await store.setStatus(sessionId, 'open');
+            }
+            catch { /* ignore */ }
+        }
     }
     if (opts.signal?.aborted) {
         emit?.({ kind: 'aborted' });
-        return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs };
+        if (store && sessionId) {
+            try {
+                await store.setStatus(sessionId, 'aborted', finalText);
+            }
+            catch { /* ignore */ }
+        }
+        await closeTracer();
+        return { status: 'aborted', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined };
     }
     emit?.({ kind: 'final_text', text: finalText });
-    return { status: 'max_steps', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs };
+    if (store && sessionId) {
+        try {
+            await store.setStatus(sessionId, 'max_steps', finalText);
+        }
+        catch { /* ignore */ }
+    }
+    await closeTracer();
+    return { status: 'max_steps', steps, toolCalls: toolCallCount, finalText, transcript, usage, repairs, verification: hasEdits ? { ok: false, attempts: verificationAttempts } : undefined };
 }
 function redactOutput(v) {
     if (typeof v === 'string')

package/dist/chat.d.ts

@@ -27,9 +27,9 @@ export declare function normalizeBaseURL(url: string): string;
 export declare function assertSafeBaseURL(url: string): void;
 export declare function chat(prompt: string, system: string, modelOverride?: string, opts?: ChatOptions): Promise<void>;
 /**
- * Parse SSE frames and write text deltas to stdout. Each `data: ...` line is
- * one chunk; `[DONE]` terminates the stream. Respects backpressure on stdout
- * and the provided abort signal.
+ * Parse SSE frames and write text deltas to stdout. Handles
+ * fragmented chunks by buffering and splitting on \n\n event boundary.
+ * Respects backpressure on stdout and the provided abort signal.
  */
 export declare function streamToStdout(body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void>;
 /**

package/dist/chat.js

@@ -34,10 +34,18 @@ export function assertSafeBaseURL(url) {
         return;
     if (parsed.protocol === 'http:') {
         const host = parsed.hostname.toLowerCase();
-        if (host === 'localhost' || host === '127.0.0.1' || host === '::1')
+        // Allow loopback equivalents: localhost, 127.0.0.1, ::1, 0.0.0.0, ::, 127.x.x.x is NOT allowed without https
+        // Note: hostnames that resolve to loopback (e.g. nip.io) still require https — we check hostname, not DNS.
+        if (host === 'localhost' || host === '127.0.0.1' || host === '::1' || host === '0.0.0.0' || host === '::' || host === '[::]')
             return;
+        // Also allow 127.0.0.0/8 range via prefix check (e.g. 127.0.0.2)
+        if (host.startsWith('127.')) {
+            const parts = host.split('.');
+            if (parts.length === 4 && parts.every((p) => /^\d+$/.test(p) && Number(p) >= 0 && Number(p) <= 255))
+                return;
+        }
         throw new Error(`Refusing to send KLYRO_API_KEY over plaintext HTTP to ${host}. ` +
-            `Use https:// or a localhost URL.`);
+            `Use https:// or a localhost URL (localhost, 127.0.0.1, ::1, 0.0.0.0).`);
     }
     throw new Error(`Unsupported KLYRO_BASE_URL protocol: ${parsed.protocol}`);
 }
@@ -53,12 +61,17 @@ export async function chat(prompt, system, modelOverride, opts = {}) {
     assertSafeBaseURL(baseURL);
     const ac = new AbortController();
     const timeout = setTimeout(() => ac.abort(new Error(`request timed out after ${timeoutMs}ms`)), timeoutMs);
+    // Ensure timer is always cleared — use try/finally pattern
+    const clearTimer = () => clearTimeout(timeout);
     // If the caller passed their own signal, abort when they abort.
+    let callerAbortHandler;
     if (opts.signal) {
         if (opts.signal.aborted)
             ac.abort(opts.signal.reason);
-        else
-            opts.signal.addEventListener('abort', () => ac.abort(opts.signal?.reason), { once: true });
+        else {
+            callerAbortHandler = () => ac.abort(opts.signal?.reason);
+            opts.signal.addEventListener('abort', callerAbortHandler, { once: true });
+        }
     }
     let res;
     try {
@@ -80,12 +93,16 @@ export async function chat(prompt, system, modelOverride, opts = {}) {
         });
     }
     catch (err) {
-        clearTimeout(timeout);
+        clearTimer();
+        if (callerAbortHandler && opts.signal)
+            opts.signal.removeEventListener('abort', callerAbortHandler);
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`klyro: request failed: ${msg}`);
         process.exit(1);
     }
-    clearTimeout(timeout);
+    clearTimer();
+    if (callerAbortHandler && opts.signal)
+        opts.signal.removeEventListener('abort', callerAbortHandler);
     if (!res.ok) {
         const text = await readBoundedText(res.body, MAX_ERROR_BODY_BYTES);
         console.error(`klyro: HTTP ${res.status} ${res.statusText}\n${text}`);
@@ -109,9 +126,9 @@ export async function chat(prompt, system, modelOverride, opts = {}) {
     }
 }
 /**
- * Parse SSE frames and write text deltas to stdout. Each `data: ...` line is
- * one chunk; `[DONE]` terminates the stream. Respects backpressure on stdout
- * and the provided abort signal.
+ * Parse SSE frames and write text deltas to stdout. Handles
+ * fragmented chunks by buffering and splitting on \n\n event boundary.
+ * Respects backpressure on stdout and the provided abort signal.
  */
 export async function streamToStdout(body, signal) {
     const reader = body.getReader();
@@ -126,38 +143,77 @@ export async function streamToStdout(body, signal) {
             if (done)
                 break;
             buf += decoder.decode(value, { stream: true });
+            // SSE events are separated by \n\n — handle fragmented deliveries
             let idx;
-            while ((idx = buf.indexOf('\n')) !== -1) {
+            while ((idx = buf.indexOf('\n\n')) !== -1) {
                 if (signal.aborted)
                     throw new Error('aborted');
-                const line = buf.slice(0, idx).replace(/\r$/, '');
-                buf = buf.slice(idx + 1);
-                if (!line.startsWith('data:'))
-                    continue;
-                const data = line.slice(5).trim();
-                if (data === '[DONE]') {
-                    process.stdout.write('\n');
-                    return;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(data);
-                }
-                catch {
-                    continue;
-                }
-                const text = parsed.choices?.[0]?.delta?.content;
-                if (text) {
-                    if (!await writeWithBackpressure(text)) {
-                        // stdout closed (pipe severed). Stop reading.
-                        try {
-                            await reader.cancel();
-                        }
-                        catch {
-                            /* ignore */
+                const event = buf.slice(0, idx);
+                buf = buf.slice(idx + 2);
+                for (const rawLine of event.split('\n')) {
+                    const line = rawLine.replace(/\r$/, '');
+                    if (!line.startsWith('data:'))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === '[DONE]') {
+                        process.stdout.write('\n');
+                        return;
+                    }
+                    // Handle case where data was split across chunks and reassembled as event
+                    if (data === '')
+                        continue;
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const text = parsed.choices?.[0]?.delta?.content;
+                    if (text) {
+                        if (!await writeWithBackpressure(text, signal)) {
+                            try {
+                                await reader.cancel();
+                            }
+                            catch { /* ignore */ }
+                            return;
                         }
+                    }
+                }
+            }
+            // Also handle single \n lines that haven't yet formed \n\n (for providers that send \n only)
+            // Process remaining complete lines if no \n\n found but buffer has \n
+            if (buf.includes('\n') && !buf.includes('\n\n')) {
+                const lines = buf.split('\n');
+                // Keep last incomplete line in buf
+                buf = lines.pop() ?? '';
+                for (const rawLine of lines) {
+                    const line = rawLine.replace(/\r$/, '');
+                    if (!line.startsWith('data:'))
+                        continue;
+                    const data = line.slice(5).trim();
+                    if (data === '[DONE]') {
+                        process.stdout.write('\n');
                         return;
                     }
+                    if (data === '')
+                        continue;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const text = parsed.choices?.[0]?.delta?.content;
+                        if (text) {
+                            if (!await writeWithBackpressure(text, signal)) {
+                                try {
+                                    await reader.cancel();
+                                }
+                                catch { /* ignore */ }
+                                return;
+                            }
+                        }
+                    }
+                    catch {
+                        continue;
+                    }
                 }
             }
         }
@@ -175,20 +231,47 @@ export async function streamToStdout(body, signal) {
 /**
  * Write to stdout and wait for the drain event if the buffer is full.
  * Returns false if stdout has been closed (e.g. piped to `head`).
+ * Respects abort signal — resolves false if aborted while waiting.
  */
-function writeWithBackpressure(chunk) {
+function writeWithBackpressure(chunk, signal) {
     return new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve(false);
+            return;
+        }
         if (!process.stdout.write(chunk)) {
-            const onDrain = () => {
+            let settled = false;
+            const cleanup = () => {
+                process.stdout.off('drain', onDrain);
                 process.stdout.off('error', onError);
+                if (signal)
+                    signal.removeEventListener('abort', onAbort);
+            };
+            const onDrain = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
                 resolve(true);
             };
             const onError = () => {
-                process.stdout.off('drain', onDrain);
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(false);
+            };
+            const onAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
                 resolve(false);
             };
             process.stdout.once('drain', onDrain);
             process.stdout.once('error', onError);
+            if (signal)
+                signal.addEventListener('abort', onAbort, { once: true });
         }
         else {
             resolve(true);
@@ -207,9 +290,18 @@ export async function readBoundedText(body, max) {
     const chunks = [];
     try {
         while (received < max) {
-            const { value, done } = await reader.read();
+            let result;
+            try {
+                result = await reader.read();
+            }
+            catch {
+                break;
+            }
+            const { value, done } = result;
             if (done)
                 break;
+            if (!value)
+                break;
             const remaining = max - received;
             if (value.byteLength <= remaining) {
                 chunks.push(value);
@@ -228,6 +320,12 @@ export async function readBoundedText(body, max) {
         catch {
             /* ignore */
         }
+        try {
+            await reader.cancel().catch(() => undefined);
+        }
+        catch {
+            /* ignore */
+        }
     }
     const decoder = new TextDecoder('utf-8');
     const text = decoder.decode(Buffer.concat(chunks));

package/dist/cli/auth.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 2.2 — klyro login / logout / aliases
+ * Stores masked key → ~/.klyro/credentials.json 0600
+ */
+export declare function runLogin(): Promise<number>;
+export declare function runLogout(provider?: string): Promise<number>;
+export declare function getStoredKey(provider: string): string | undefined;
+export declare const MODEL_ALIASES: Record<string, string>;
+export declare function resolveAlias(model: string): string;