klyro 0.1.4 → 0.1.5

package/dist/agent/anthropic-adapter.d.ts

@@ -60,7 +60,7 @@ export declare function anthropicAdapter(opts: AnthropicAdapterOptions): Provide
 declare function findToolIdByIndex(index: number | undefined, buffers: Map<string, {
     name: string;
     argsJson: string;
-}>): string | undefined;
+}>, indexToToolId?: Map<number, string>): string | undefined;
 declare function toAnthropicMessages(messages: Message[]): AnthropicMessage[];
 declare function toAnthropicTool(t: ToolDefinition): {
     name: string;

package/dist/agent/anthropic-adapter.js

@@ -14,6 +14,7 @@
  * Auth: `x-api-key: <key>`. Version header is sent as `anthropic-version`.
  * Auth can be a Bearer token (for proxies) — the adapter accepts either.
  */
+import { assertSafeBaseURL } from '../chat.js';
 const DEFAULT_VERSION = '2023-06-01';
 const DEFAULT_TIMEOUT_MS = 120_000;
 export class AnthropicApiError extends Error {
@@ -27,7 +28,9 @@ export class AnthropicApiError extends Error {
     }
 }
 export function anthropicAdapter(opts) {
-    const baseURL = (opts.baseURL ?? 'https://api.anthropic.com').replace(/\/+$/, '');
+    const rawBase = opts.baseURL ?? 'https://api.anthropic.com';
+    assertSafeBaseURL(rawBase);
+    const baseURL = rawBase.replace(/\/+$/, '');
     const version = opts.anthropicVersion ?? DEFAULT_VERSION;
     const authHeader = opts.authHeader ?? 'x-api-key';
     const betas = opts.betas ?? [];
@@ -110,6 +113,8 @@ async function* streamAnthropic(req, opts) {
     let buf = '';
     // Track in-progress tool calls so we can emit start/delta/end.
     const toolBuffers = new Map();
+    // Map content_block index → tool_use id (persists after tool completes to handle late deltas)
+    const indexToToolId = new Map();
     try {
         while (true) {
             const { value, done } = await reader.read();
@@ -146,7 +151,7 @@ async function* streamAnthropic(req, opts) {
                 catch {
                     continue;
                 }
-                const out = translateSse(e.event, parsed, toolBuffers);
+                const out = translateSse(e.event, parsed, toolBuffers, indexToToolId);
                 for (const ev of out)
                     yield ev;
             }
@@ -162,13 +167,16 @@ async function* streamAnthropic(req, opts) {
     }
     yield { kind: 'message_end', finishReason: 'stop' };
 }
-function translateSse(event, parsed, toolBuffers) {
+function translateSse(event, parsed, toolBuffers, indexToToolId) {
     const out = [];
     switch (event) {
         case 'content_block_start': {
             const block = parsed.content_block;
+            const idx = parsed.index;
             if (block?.type === 'tool_use' && block.id && block.name) {
                 toolBuffers.set(block.id, { name: block.name, argsJson: '' });
+                if (idx !== undefined)
+                    indexToToolId.set(idx, block.id);
                 out.push({ kind: 'tool_call_start', id: block.id, name: block.name });
             }
             return out;
@@ -176,16 +184,11 @@ function translateSse(event, parsed, toolBuffers) {
         case 'content_block_delta': {
             const delta = parsed.delta;
             const index = parsed.index;
-            // We need the id to know which tool buffer to update. Anthropic sends
-            // index but not id on delta events. Match by name+index pair.
             if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
                 out.push({ kind: 'text_delta', text: delta.text });
             }
             else if (delta?.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
-                // Find the tool buffer whose index matches this delta.
-                // We map by index order: the i-th tool_use block corresponds to the
-                // i-th tool_start we've emitted. Track that counter separately.
-                const id = findToolIdByIndex(index, toolBuffers);
+                const id = findToolIdByIndex(index, toolBuffers, indexToToolId);
                 if (id) {
                     const buf = toolBuffers.get(id);
                     if (buf) {
@@ -197,12 +200,11 @@ function translateSse(event, parsed, toolBuffers) {
             return out;
         }
         case 'content_block_stop': {
-            // The 'index' of the stopped block tells us which tool finished.
-            // We track tool starts in order and match by index.
             const index = parsed.index;
-            const id = findToolIdByIndex(index, toolBuffers);
+            const id = findToolIdByIndex(index, toolBuffers, indexToToolId);
             if (id) {
                 toolBuffers.delete(id);
+                // Keep index mapping for late deltas that may arrive after stop (rare)
                 out.push({ kind: 'tool_call_end', id });
             }
             return out;
@@ -226,22 +228,22 @@ function translateSse(event, parsed, toolBuffers) {
     }
 }
 /** Match an Anthropic content_block index to the tool_use id we emitted. */
-function findToolIdByIndex(index, buffers) {
+function findToolIdByIndex(index, buffers, indexToToolId) {
     if (index === undefined)
         return undefined;
-    // buffers is a Map preserving insertion order. The index of a tool_use
-    // block is its position among all content blocks, not just tool_use
-    // blocks. We don't know about non-tool blocks, so we use a simpler
-    // heuristic: the index matches the i-th tool_use that has been started
-    // since message_start. This is good enough for streamed responses where
-    // tool blocks are typically 0,1,2...
+    // Preferred: direct index → id mapping from content_block_start
+    if (indexToToolId) {
+        const direct = indexToToolId.get(index);
+        if (direct)
+            return direct;
+    }
+    // Fallback heuristic for older streams without index on start
     let i = 0;
     for (const id of buffers.keys()) {
         if (i === index)
             return id;
         i++;
     }
-    // Fallback: if there's exactly one tool in flight, it's almost certainly it.
     if (buffers.size === 1)
         return buffers.keys().next().value;
     return undefined;

package/dist/agent/provider-adapter.js

@@ -10,6 +10,7 @@
  * The adapter exposes a single async generator of StreamEvents so the
  * runtime loop sees one shape regardless of provider quirks.
  */
+import { redact } from '../policy/secret-redactor.js';
 const DEFAULT_TIMEOUT_MS = 120_000;
 /** Convert a Zod schema to a permissive JSON Schema object for tool defs. */
 export function zodToJsonSchema(schema) {
@@ -18,7 +19,7 @@ export function zodToJsonSchema(schema) {
     // inputs are flat objects with primitive types.
     const def = schema._def;
     if (!def)
-        return { type: 'object', properties: {}, additionalProperties: true };
+        return { type: 'object', properties: {}, additionalProperties: false };
     if (def.typeName === 'ZodObject' && def.shape) {
         const props = {};
         const required = [];
@@ -33,7 +34,7 @@ export function zodToJsonSchema(schema) {
         out.additionalProperties = false;
         return out;
     }
-    return { type: 'object', properties: {}, additionalProperties: true };
+    return { type: 'object', properties: {}, additionalProperties: false };
 }
 function zodFieldSchema(s) {
     const def = s._def;
@@ -124,7 +125,7 @@ export function buildChatCompletionsBody(req) {
 }
 export function httpChatAdapter(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
-    const url = `${opts.baseURL.replace(/\/$/, '')}/chat/completions`;
+    const url = `${opts.baseURL.replace(/\/+$/, '')}/chat/completions`;
     return {
         id: 'http-chat',
         stream(req) {
@@ -161,11 +162,12 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
     if (!res.ok || !res.body) {
         clearTimeout(timer);
         req.signal?.removeEventListener('abort', onAbort);
-        const errText = await res.text().catch(() => '');
+        const rawErr = await res.text().catch(() => '');
+        const errText = redact(rawErr).slice(0, 500);
         yield {
             kind: 'error',
             code: `HTTP_${res.status}`,
-            message: `provider returned ${res.status}: ${errText.slice(0, 500)}`,
+            message: `provider returned ${res.status}: ${errText}`,
             retryable: res.status >= 500 || res.status === 429,
         };
         return;
@@ -177,6 +179,7 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
     // Track per-tool-call id by index.
     const toolIds = new Map();
     const toolNames = new Map();
+    let pendingUsage;
     try {
         while (true) {
             const { value, done } = await reader.read();
@@ -203,6 +206,10 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
                     catch {
                         continue;
                     }
+                    // Capture usage even when finish_reason is null (Ollama/vLLM style)
+                    if (chunk.usage) {
+                        pendingUsage = { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens };
+                    }
                     for (const choice of chunk.choices) {
                         if (choice.delta.content) {
                             yield { kind: 'text_delta', text: choice.delta.content };
@@ -222,9 +229,16 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
                             }
                         }
                         if (choice.finish_reason) {
-                            const usage = chunk.usage
+                            const usage = pendingUsage ?? (chunk.usage
                                 ? { input: chunk.usage.prompt_tokens, output: chunk.usage.completion_tokens }
-                                : undefined;
+                                : undefined);
+                            pendingUsage = undefined;
+                            // Clear tool tracking per message to avoid stale ids on next turn
+                            const ids = [...toolIds.values()];
+                            toolIds.clear();
+                            toolNames.clear();
+                            for (const id of ids)
+                                yield { kind: 'tool_call_end', id };
                             yield { kind: 'message_end', finishReason: choice.finish_reason, usage };
                         }
                     }
@@ -234,6 +248,15 @@ async function* streamChatCompletions(url, opts, req, fetchImpl) {
         if (toolIds.size) {
             for (const id of toolIds.values())
                 yield { kind: 'tool_call_end', id };
+            if (pendingUsage) {
+                yield { kind: 'message_end', usage: pendingUsage };
+            }
+            else {
+                yield { kind: 'message_end' };
+            }
+        }
+        else if (pendingUsage) {
+            yield { kind: 'message_end', usage: pendingUsage };
         }
         else {
             yield { kind: 'message_end' };

package/dist/agent/registry.js

@@ -19,9 +19,10 @@
 import { httpChatAdapter } from './provider-adapter.js';
 import { anthropicAdapter } from './anthropic-adapter.js';
 import { retryingAdapter } from './retry.js';
-/** Heuristic: hosts that look like Anthropic's API. */
+/** Heuristic: hosts that look like Anthropic's API. Only matches anthropic.com and subdomains, not substring. */
 function looksLikeAnthropic(host) {
-    return /(^|\.)anthropic\.com$/i.test(host) || /anthropic/i.test(host);
+    const h = host.toLowerCase();
+    return h === 'anthropic.com' || h.endsWith('.anthropic.com');
 }
 export function inferProviderFromBaseURL(baseURL) {
     if (!baseURL)
@@ -34,6 +35,18 @@ export function inferProviderFromBaseURL(baseURL) {
         return 'openai';
     }
 }
+function isLoopbackBaseURL(url) {
+    if (!url)
+        return false;
+    try {
+        const u = new URL(url);
+        const h = u.hostname.toLowerCase();
+        return h === 'localhost' || h === '127.0.0.1' || h === '::1' || h === '0.0.0.0' || h === '::' || h.startsWith('127.');
+    }
+    catch {
+        return false;
+    }
+}
 export function buildProvider(opts = {}) {
     const baseURL = opts.baseURL ?? process.env.KLYRO_BASE_URL;
     const apiKey = opts.apiKey ?? process.env.KLYRO_API_KEY;
@@ -52,15 +65,19 @@ export function buildProvider(opts = {}) {
     let inner;
     if (provider === 'anthropic') {
         if (!apiKey) {
-            throw new Error('buildProvider: anthropic provider requires an apiKey (or KLYRO_API_KEY).');
+            throw new Error('klyro: invalid --provider: anthropic requires an API key (set KLYRO_API_KEY or pass --api-key)');
         }
         inner = anthropicAdapter({ baseURL, apiKey, timeoutMs });
     }
     else {
-        if (!baseURL || !apiKey) {
-            throw new Error('buildProvider: openai provider requires baseURL and apiKey (or KLYRO_BASE_URL + KLYRO_API_KEY).');
+        if (!baseURL) {
+            throw new Error('klyro: invalid --provider: openai requires --base-url or KLYRO_BASE_URL');
+        }
+        // Allow empty apiKey for loopback local servers (Ollama etc.)
+        if (!apiKey && !isLoopbackBaseURL(baseURL)) {
+            throw new Error('klyro: invalid --provider: openai requires --api-key or KLYRO_API_KEY (or use a localhost URL for local models)');
         }
-        inner = httpChatAdapter({ baseURL, apiKey, timeoutMs });
+        inner = httpChatAdapter({ baseURL, apiKey: apiKey ?? '', timeoutMs });
     }
     if (opts.retry === false)
         return inner;
@@ -75,7 +92,7 @@ export function buildProvider(opts = {}) {
 export function buildProviderFromCli(args) {
     const provider = args.provider;
     if (provider && provider !== 'openai' && provider !== 'anthropic') {
-        throw new Error(`unknown provider: ${provider}`);
+        throw new Error(`klyro: invalid --provider: ${provider} (expected openai|anthropic)`);
     }
     return buildProvider({
         provider,

package/dist/agent/retry.js

@@ -33,13 +33,28 @@ async function* streamWithAbort(source, signal) {
         return;
     }
     const it = source[Symbol.asyncIterator]();
-    while (true) {
-        if (signal.aborted)
-            return;
-        const next = await it.next();
-        if (next.done)
-            return;
-        yield next.value;
+    try {
+        while (true) {
+            if (signal.aborted) {
+                try {
+                    await it.return?.();
+                }
+                catch { /* ignore */ }
+                return;
+            }
+            const next = await it.next();
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+    finally {
+        if (signal.aborted) {
+            try {
+                await it.return?.();
+            }
+            catch { /* ignore */ }
+        }
     }
 }
 export function computeBackoff(attempt, baseMs, maxMs) {
@@ -54,14 +69,44 @@ export function retryingAdapter(inner, opts = {}) {
     return {
         id: `${inner.id}+retry`,
         async *stream(req, signal) {
-            const effectiveSignal = signal ?? opts.signal;
+            // Support both calling conventions: stream(req) where req.signal is set, and legacy stream(req, signal)
+            // Combine per-request signal (req.signal), legacy second-arg signal, and adapter-level opts.signal
+            const getEffectiveSignal = (legacySignal) => {
+                const sigs = [req.signal, legacySignal, opts.signal].filter(Boolean);
+                if (sigs.length === 0)
+                    return undefined;
+                if (sigs.length === 1)
+                    return sigs[0];
+                // If any aborts, effective aborts — create a combined controller
+                const ctrl = new AbortController();
+                const onAbort = () => {
+                    const reason = sigs.find((s) => s.aborted)?.reason ?? sigs[0]?.reason;
+                    try {
+                        ctrl.abort(reason);
+                    }
+                    catch {
+                        ctrl.abort();
+                    }
+                };
+                if (sigs.some((s) => s.aborted)) {
+                    onAbort();
+                }
+                else {
+                    for (const s of sigs)
+                        s.addEventListener('abort', onAbort, { once: true });
+                }
+                return ctrl.signal;
+            };
             for (let attempt = 0; attempt < cfg.maxAttempts; attempt++) {
+                const effectiveSignal = getEffectiveSignal(signal);
+                // Clone req per attempt to avoid reusing aborted signal
+                const attemptReq = effectiveSignal ? { ...req, signal: effectiveSignal } : req;
                 opts.onAttempt?.(attempt);
                 if (effectiveSignal?.aborted)
                     return;
                 let sawRetryable = false;
                 let lastError = null;
-                for await (const ev of streamWithAbort(inner.stream(req), effectiveSignal)) {
+                for await (const ev of streamWithAbort(inner.stream(attemptReq), effectiveSignal)) {
                     if (effectiveSignal?.aborted)
                         return;
                     if (ev.kind === 'error' && ev.retryable) {

package/dist/agent/runtime.d.ts

@@ -40,6 +40,8 @@ export interface RunOptions {
     cwd: string;
     model: string;
     maxSteps?: number;
+    /** Alias for maxSteps (3.5) */
+    maxTurns?: number;
     maxTokens?: number;
     temperature?: number;
     signal?: AbortSignal;
@@ -60,6 +62,27 @@ export interface RunOptions {
      * that don't pass it pay zero cost.
      */
     onEvent?: (ev: RuntimeEvent) => void;
+    /**
+     * Level 8 — verification config. When enabled and the agent has edited
+     * files, the runtime auto-runs a verification command after the agent
+     * claims completion, feeds failure diagnostics back, and retries up to
+     * maxRepairAttempts.
+     */
+    verify?: {
+        enabled?: boolean;
+        command?: string;
+        maxRepairAttempts?: number;
+        timeoutMs?: number;
+    };
+    /**
+     * Level 9 — persistence. When a SessionStore is provided, every message
+     * and observation is checkpointed through it. This enables resume after
+     * interrupt and history inspection.
+     */
+    persist?: {
+        store?: import('../persistence/store.js').SessionStore;
+        sessionId?: string;
+    };
 }
 /** A single plan step emitted by the agent. */
 export interface PlanStep {
@@ -125,9 +148,23 @@ export type RuntimeEvent = {
     kind: 'verification_failed';
     step: string;
     reason: string;
+} | {
+    kind: 'verification_started';
+    command: string;
+} | {
+    kind: 'verification_succeeded';
+    command: string;
+} | {
+    kind: 'repair_started';
+    attempt: number;
+    maxAttempts: number;
+    reason: string;
+} | {
+    kind: 'checkpoint_saved';
+    sessionId: string;
 };
 export interface RunResult {
-    status: 'complete' | 'max_steps' | 'aborted' | 'no_final';
+    status: 'complete' | 'max_steps' | 'aborted' | 'no_final' | 'verify_failed';
     steps: number;
     toolCalls: number;
     finalText: string;
@@ -138,6 +175,13 @@ export interface RunResult {
     };
     /** Number of policy-driven user prompts the user accepted. */
     repairs?: number;
+    /** Verification outcome (Level 8) */
+    verification?: {
+        ok: boolean;
+        command?: string;
+        attempts: number;
+        failureType?: string;
+    };
 }
 /** Convert a registry of tools into ToolDefinitions for the provider. */
 export declare function toolDefinitions(registry: ToolRegistry): ToolDefinition[];