@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/layer4-sprint-vs.test.js

@@ -0,0 +1,105 @@
+/**
+ * Layer 4 Sprint VS: Value Surfacing tests.
+ */
+import { describe, expect, it } from "vitest";
+import { formatGuardMoment, getDollarGate, shouldFireGuard, } from "../behaviors/guard-formatter.js";
+import { getValueSurfacingConfig, resetValueSurfacingConfig, setValueSurfacingConfig, } from "../config/value-surfacing.js";
+import { createIntelligenceCounter } from "../tracking/intelligence-counter.js";
+import { frameGuardMoment, frameSessionSummary, frameTokenSavings, frameWeeklyTrend, } from "../utils/counterfactual.js";
+describe("Counterfactual Framing (VS.8)", () => {
+    it("frames token savings with 'without unerr' language", () => {
+        const msg = frameTokenSavings(45000, 0.135);
+        expect(msg).toContain("Without unerr");
+        expect(msg).toContain("45.0K");
+        expect(msg).toContain("$");
+    });
+    it("frames guard moment with prevented cost", () => {
+        const msg = frameGuardMoment("hallucination loop detected", 2.13);
+        expect(msg).toContain("[unerr]");
+        expect(msg).toContain("Prevented");
+        expect(msg).toContain("$2.13");
+    });
+    it("frames session summary", () => {
+        const msg = frameSessionSummary(23000, 0.069, 2);
+        expect(msg).toContain("Without unerr");
+        expect(msg).toContain("23.0K");
+        expect(msg).toContain("2 issue(s) prevented");
+    });
+    it("frames session with zero events positively", () => {
+        const msg = frameSessionSummary(0, 0, 0);
+        expect(msg).toContain("monitoring");
+        expect(msg).not.toContain("Without unerr");
+    });
+    it("frames weekly trend", () => {
+        const msg = frameWeeklyTrend(45000, 30000, 0.135);
+        expect(msg).toContain("↑");
+        expect(msg).toContain("This week");
+    });
+});
+describe("Guard Formatter (VS.4)", () => {
+    it("fires guard when >$0.50 threshold", () => {
+        const tokens = 200_000;
+        expect(shouldFireGuard(tokens)).toBe(true);
+    });
+    it("does not fire guard below $0.50 threshold", () => {
+        const tokens = 100;
+        expect(shouldFireGuard(tokens)).toBe(false);
+    });
+    it("dollar gate is $0.50", () => {
+        expect(getDollarGate()).toBe(0.5);
+    });
+    it("formatGuardMoment returns null below threshold", () => {
+        const result = formatGuardMoment("test", 10);
+        expect(result).toBeNull();
+    });
+    it("formatGuardMoment returns GuardMoment above threshold", () => {
+        const result = formatGuardMoment("loop detected", 500_000);
+        expect(result).not.toBeNull();
+        expect(result?.passed).toBe(true);
+        expect(result?.dollarsPrevented).toBeGreaterThanOrEqual(0.5);
+    });
+});
+describe("Intelligence Counter (VS.7)", () => {
+    it("tracks metrics", () => {
+        const counter = createIntelligenceCounter();
+        counter.record("entityCount", 847);
+        counter.record("edgeCount", 2134);
+        counter.record("communitiesDetected", 8);
+        counter.increment("conventionsLearned");
+        counter.increment("conventionsLearned");
+        const metrics = counter.getMetrics();
+        expect(metrics.entityCount).toBe(847);
+        expect(metrics.edgeCount).toBe(2134);
+        expect(metrics.conventionsLearned).toBe(2);
+    });
+    it("formats summary string", () => {
+        const counter = createIntelligenceCounter();
+        counter.record("entityCount", 1247);
+        counter.record("edgeCount", 3456);
+        counter.record("communitiesDetected", 12);
+        const summary = counter.formatSummary();
+        expect(summary).toContain("1,247 entities");
+        expect(summary).toContain("3,456 edges");
+        expect(summary).toContain("12 communities");
+    });
+    it("resets all metrics", () => {
+        const counter = createIntelligenceCounter();
+        counter.record("entityCount", 100);
+        counter.reset();
+        expect(counter.getMetrics().entityCount).toBe(0);
+    });
+});
+describe("Value Surfacing Config (VS.9)", () => {
+    it("has sensible defaults", () => {
+        resetValueSurfacingConfig();
+        const config = getValueSurfacingConfig();
+        expect(config.guardThresholdDollars).toBe(0.5);
+        expect(config.weeklyEnabled).toBe(true);
+        expect(config.scorecardEnabled).toBe(true);
+    });
+    it("allows overrides", () => {
+        setValueSurfacingConfig({ guardThresholdDollars: 1.0 });
+        expect(getValueSurfacingConfig().guardThresholdDollars).toBe(1.0);
+        resetValueSurfacingConfig();
+    });
+});

package/dist/__tests__/ledger-chains.test.js

@@ -0,0 +1,162 @@
+import { describe, expect, it } from "vitest";
+import { extractChains, getEntityHistory, getRevertPatterns, getSessionTimeline, } from "../tracking/ledger-chains.js";
+function makeEntry(overrides = {}) {
+    return {
+        id: `entry-${Math.random().toString(36).slice(2, 8)}`,
+        ts: new Date().toISOString(),
+        tool: "get_function",
+        args_summary: {},
+        result_summary: {},
+        branch: "main",
+        head_sha: "abc123",
+        session_id: "sess-001",
+        correlation_id: null,
+        ...overrides,
+    };
+}
+describe("ledger-chains", () => {
+    describe("extractChains", () => {
+        it("groups entries by correlation_id into chains", () => {
+            const root = makeEntry({ id: "root-1", correlation_id: null });
+            const child1 = makeEntry({ id: "c1", correlation_id: "root-1" });
+            const child2 = makeEntry({ id: "c2", correlation_id: "root-1" });
+            const standalone = makeEntry({ id: "root-2", correlation_id: null });
+            const chains = extractChains([root, child1, child2, standalone]);
+            expect(chains.length).toBe(2);
+            const mainChain = chains.find((c) => c.root_id === "root-1");
+            expect(mainChain).toBeDefined();
+            expect(mainChain.entries.length).toBe(3);
+        });
+        it("extracts entities from chain entries", () => {
+            const root = makeEntry({
+                id: "r",
+                correlation_id: null,
+                args_summary: { key: "src/auth.ts::login" },
+            });
+            const child = makeEntry({
+                id: "c",
+                correlation_id: "r",
+                args_summary: { file_path: "src/auth.ts" },
+            });
+            const chains = extractChains([root, child]);
+            expect(chains[0].entities_touched).toContain("src/auth.ts::login");
+            expect(chains[0].entities_touched).toContain("src/auth.ts");
+        });
+        it("classifies reverted chains", () => {
+            const root = makeEntry({
+                id: "r",
+                correlation_id: null,
+                tool: "get_function",
+            });
+            const revert = makeEntry({
+                id: "c",
+                correlation_id: "r",
+                tool: "unerr_revert_to_working_state",
+            });
+            const chains = extractChains([root, revert]);
+            expect(chains[0].outcome).toBe("reverted");
+        });
+        it("classifies modified chains (sync_local_diff present)", () => {
+            const root = makeEntry({
+                id: "r",
+                correlation_id: null,
+                tool: "get_function",
+            });
+            const sync = makeEntry({
+                id: "c",
+                correlation_id: "r",
+                tool: "sync_local_diff",
+            });
+            const chains = extractChains([root, sync]);
+            expect(chains[0].outcome).toBe("modified");
+        });
+    });
+    describe("getEntityHistory", () => {
+        it("returns chains that touched a specific entity", () => {
+            const entries = [
+                makeEntry({
+                    id: "r1",
+                    correlation_id: null,
+                    args_summary: { key: "src/proxy.ts::startProxy" },
+                }),
+                makeEntry({
+                    id: "r2",
+                    correlation_id: null,
+                    args_summary: { key: "src/auth.ts::login" },
+                }),
+            ];
+            const history = getEntityHistory(entries, "src/proxy.ts");
+            expect(history.length).toBe(1);
+            expect(history[0].entities_touched).toContain("src/proxy.ts::startProxy");
+        });
+        it("limits results", () => {
+            const entries = Array.from({ length: 30 }, (_, i) => makeEntry({
+                id: `r${i}`,
+                correlation_id: null,
+                args_summary: { file_path: "src/hot.ts" },
+            }));
+            const history = getEntityHistory(entries, "src/hot.ts", 5);
+            expect(history.length).toBe(5);
+        });
+    });
+    describe("getRevertPatterns", () => {
+        it("detects tool sequences that lead to reverts", () => {
+            const entries = [];
+            // Create 3 chains with same tool sequence, 2 reverted
+            for (let i = 0; i < 3; i++) {
+                const rootId = `root-${i}`;
+                entries.push(makeEntry({ id: rootId, correlation_id: null, tool: "get_function" }), makeEntry({
+                    id: `c${i}-1`,
+                    correlation_id: rootId,
+                    tool: "file_read",
+                }), makeEntry({
+                    id: `c${i}-2`,
+                    correlation_id: rootId,
+                    tool: i < 2 ? "unerr_revert_to_working_state" : "get_callers",
+                }));
+            }
+            const patterns = getRevertPatterns(entries, 2);
+            expect(patterns.length).toBeGreaterThan(0);
+            const mainPattern = patterns.find((p) => p.tool_sequence.includes("get_function"));
+            expect(mainPattern).toBeDefined();
+            expect(mainPattern.revert_rate).toBeGreaterThan(0);
+        });
+        it("returns empty when no reverts", () => {
+            const entries = [
+                makeEntry({ id: "r1", correlation_id: null, tool: "get_function" }),
+                makeEntry({ id: "r2", correlation_id: null, tool: "get_callers" }),
+            ];
+            const patterns = getRevertPatterns(entries);
+            expect(patterns.length).toBe(0);
+        });
+    });
+    describe("getSessionTimeline", () => {
+        it("groups entries by session_id", () => {
+            const entries = [
+                makeEntry({ session_id: "s1", tool: "get_function" }),
+                makeEntry({ session_id: "s1", tool: "get_callers" }),
+                makeEntry({ session_id: "s2", tool: "search_code" }),
+            ];
+            const timeline = getSessionTimeline(entries);
+            expect(timeline.length).toBe(2);
+            const s1 = timeline.find((s) => s.session_id === "s1");
+            expect(s1).toBeDefined();
+            expect(s1.tool_calls).toBe(2);
+            expect(s1.tools_used.get_function).toBe(1);
+        });
+        it("counts facts recorded", () => {
+            const entries = [
+                makeEntry({ session_id: "s1", tool: "record_fact" }),
+                makeEntry({ session_id: "s1", tool: "record_fact" }),
+                makeEntry({ session_id: "s1", tool: "get_function" }),
+            ];
+            const timeline = getSessionTimeline(entries);
+            expect(timeline[0].facts_recorded).toBe(2);
+        });
+        it("respects count limit", () => {
+            const entries = Array.from({ length: 30 }, (_, i) => makeEntry({ session_id: `s${i}` }));
+            const timeline = getSessionTimeline(entries, 3);
+            expect(timeline.length).toBe(3);
+        });
+    });
+});

package/dist/__tests__/lifecycle-machine.test.js

@@ -0,0 +1,226 @@
+import { describe, expect, it } from "vitest";
+import { createActor } from "xstate";
+import { createLifecycleActor } from "../proxy/lifecycle-actor.js";
+import { proxyMachine, } from "../proxy/lifecycle-machine.js";
+function makeActor() {
+    return createActor(proxyMachine, { input: { repoPath: "/test/repo" } });
+}
+function stateOf(actor) {
+    return actor.getSnapshot().value;
+}
+describe("Proxy Lifecycle Machine", () => {
+    it("starts in idle state", () => {
+        const actor = makeActor();
+        actor.start();
+        expect(stateOf(actor)).toBe("idle");
+        actor.stop();
+    });
+    it("transitions idle → detecting on START_DETECT", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        expect(stateOf(actor)).toBe("detecting");
+        actor.stop();
+    });
+    it("transitions detecting → setup when needsSetup is true", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: true });
+        expect(stateOf(actor)).toBe("setup");
+        actor.stop();
+    });
+    it("transitions detecting → indexing when needsSetup is false", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({
+            type: "DETECT_COMPLETE",
+            needsSetup: false,
+            repoId: "repo-123",
+        });
+        expect(stateOf(actor)).toBe("indexing");
+        expect(actor.getSnapshot().context.repoId).toBe("repo-123");
+        actor.stop();
+    });
+    it("transitions setup → indexing on SETUP_COMPLETE", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: true });
+        actor.send({ type: "SETUP_COMPLETE", repoId: "new-repo" });
+        expect(stateOf(actor)).toBe("indexing");
+        expect(actor.getSnapshot().context.repoId).toBe("new-repo");
+        actor.stop();
+    });
+    it("transitions indexing → ready on INDEX_COMPLETE", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "INDEX_COMPLETE" });
+        expect(stateOf(actor)).toBe("ready");
+        actor.stop();
+    });
+    it("transitions ready → running on MCP_READY", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "INDEX_COMPLETE" });
+        actor.send({ type: "MCP_READY" });
+        expect(stateOf(actor)).toBe("running");
+        expect(actor.getSnapshot().context.mcpReady).toBe(true);
+        actor.stop();
+    });
+    it("handles GRAPH_LOADED during indexing without state change", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "GRAPH_LOADED" });
+        expect(stateOf(actor)).toBe("indexing");
+        expect(actor.getSnapshot().context.graphLoaded).toBe(true);
+        actor.stop();
+    });
+    it("transitions running → shutdown on SHUTDOWN", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "INDEX_COMPLETE" });
+        actor.send({ type: "MCP_READY" });
+        actor.send({ type: "SHUTDOWN" });
+        expect(stateOf(actor)).toBe("shutdown");
+        expect(actor.getSnapshot().status).toBe("done");
+        actor.stop();
+    });
+    it("transitions running → error on ERROR", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "INDEX_COMPLETE" });
+        actor.send({ type: "MCP_READY" });
+        actor.send({ type: "ERROR", message: "something broke" });
+        expect(stateOf(actor)).toBe("error");
+        expect(actor.getSnapshot().context.error).toBe("something broke");
+        actor.stop();
+    });
+    it("transitions error → shutdown on SHUTDOWN", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "INDEX_COMPLETE" });
+        actor.send({ type: "MCP_READY" });
+        actor.send({ type: "ERROR", message: "fail" });
+        actor.send({ type: "SHUTDOWN" });
+        expect(stateOf(actor)).toBe("shutdown");
+        actor.stop();
+    });
+    it("handles ERROR during indexing", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        actor.send({ type: "ERROR", message: "index failure" });
+        expect(stateOf(actor)).toBe("error");
+        expect(actor.getSnapshot().context.error).toBe("index failure");
+        actor.stop();
+    });
+    it("handles ERROR during detecting", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "START_DETECT" });
+        actor.send({ type: "ERROR", message: "git not found" });
+        expect(stateOf(actor)).toBe("error");
+        actor.stop();
+    });
+    it("records bootStartedAt in context", () => {
+        const before = Date.now();
+        const actor = makeActor();
+        actor.start();
+        const after = Date.now();
+        const ctx = actor.getSnapshot().context;
+        expect(ctx.bootStartedAt).toBeGreaterThanOrEqual(before);
+        expect(ctx.bootStartedAt).toBeLessThanOrEqual(after);
+        actor.stop();
+    });
+    it("ignores invalid events for current state", () => {
+        const actor = makeActor();
+        actor.start();
+        actor.send({ type: "MCP_READY" });
+        expect(stateOf(actor)).toBe("idle");
+        actor.stop();
+    });
+});
+describe("Lifecycle Actor wrapper", () => {
+    it("provides imperative getState() API", () => {
+        const lifecycle = createLifecycleActor("/test");
+        expect(lifecycle.getState()).toBe("idle");
+        lifecycle.send({ type: "START_DETECT" });
+        expect(lifecycle.getState()).toBe("detecting");
+        lifecycle.stop();
+    });
+    it("provides getSnapshot() with value and context", () => {
+        const lifecycle = createLifecycleActor("/test");
+        const snap = lifecycle.getSnapshot();
+        expect(snap.value).toBe("idle");
+        expect(snap.context.repoPath).toBe("/test");
+        lifecycle.stop();
+    });
+    it("subscribe() receives state transition notifications", () => {
+        const lifecycle = createLifecycleActor("/test");
+        const states = [];
+        const sub = lifecycle.subscribe((state) => {
+            states.push(state);
+        });
+        lifecycle.send({ type: "START_DETECT" });
+        lifecycle.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        expect(states).toContain("detecting");
+        expect(states).toContain("indexing");
+        sub.unsubscribe();
+        lifecycle.stop();
+    });
+    it("waitForState() resolves when target state is reached", async () => {
+        const lifecycle = createLifecycleActor("/test");
+        lifecycle.send({ type: "START_DETECT" });
+        const promise = lifecycle.waitForState("indexing", 1000);
+        lifecycle.send({ type: "DETECT_COMPLETE", needsSetup: false });
+        await expect(promise).resolves.toBeUndefined();
+        lifecycle.stop();
+    });
+    it("waitForState() resolves immediately if already in target state", async () => {
+        const lifecycle = createLifecycleActor("/test");
+        await lifecycle.waitForState("idle", 100);
+        lifecycle.stop();
+    });
+    it("full happy path: idle → running", () => {
+        const lifecycle = createLifecycleActor("/test");
+        lifecycle.send({ type: "START_DETECT" });
+        lifecycle.send({
+            type: "DETECT_COMPLETE",
+            needsSetup: false,
+            repoId: "r1",
+        });
+        lifecycle.send({ type: "GRAPH_LOADED" });
+        lifecycle.send({ type: "INDEX_COMPLETE" });
+        lifecycle.send({ type: "MCP_READY" });
+        expect(lifecycle.getState()).toBe("running");
+        expect(lifecycle.getContext().graphLoaded).toBe(true);
+        expect(lifecycle.getContext().mcpReady).toBe(true);
+        lifecycle.stop();
+    });
+    it("full setup path: idle → setup → running", () => {
+        const lifecycle = createLifecycleActor("/test");
+        lifecycle.send({ type: "START_DETECT" });
+        lifecycle.send({ type: "DETECT_COMPLETE", needsSetup: true });
+        lifecycle.send({ type: "SETUP_COMPLETE", repoId: "new-repo" });
+        lifecycle.send({ type: "INDEX_COMPLETE" });
+        lifecycle.send({ type: "MCP_READY" });
+        expect(lifecycle.getState()).toBe("running");
+        expect(lifecycle.getContext().repoId).toBe("new-repo");
+        lifecycle.stop();
+    });
+});

package/dist/__tests__/local-chat-provider.test.js

@@ -0,0 +1,170 @@
+/**
+ * Tests for Sprint L8.1 — LocalChatProvider + ChatProvider interface.
+ */
+import http from "node:http";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { LocalChatProvider, toChatToolDefs, } from "../core/local-chat-provider.js";
+// ── Mock Ollama Server ──────────────────────────────────────
+function createMockOllamaServer() {
+    return http.createServer((req, res) => {
+        if (req.url === "/api/chat" && req.method === "POST") {
+            let body = "";
+            req.on("data", (chunk) => {
+                body += chunk;
+            });
+            req.on("end", () => {
+                res.writeHead(200, { "Content-Type": "application/x-ndjson" });
+                // Stream two chunks then done
+                res.write(`${JSON.stringify({
+                    message: { role: "assistant", content: "Hello " },
+                    done: false,
+                })}\n`);
+                res.write(`${JSON.stringify({
+                    message: { role: "assistant", content: "world!" },
+                    done: true,
+                    eval_count: 10,
+                    prompt_eval_count: 5,
+                })}\n`);
+                res.end();
+            });
+        }
+        else if (req.url === "/api/tags") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ models: [{ name: "llama3" }] }));
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    });
+}
+// ── Mock OpenAI-Compatible Server ───────────────────────────
+function createMockOpenAiServer() {
+    return http.createServer((req, res) => {
+        if (req.url === "/v1/chat/completions" && req.method === "POST") {
+            res.writeHead(200, { "Content-Type": "text/event-stream" });
+            res.write('data: {"choices":[{"delta":{"content":"Hi "},"index":0}]}\n\n');
+            res.write('data: {"choices":[{"delta":{"content":"there!"},"index":0}]}\n\n');
+            res.write("data: [DONE]\n\n");
+            res.end();
+        }
+        else if (req.url === "/v1/models") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ data: [{ id: "llama3" }] }));
+        }
+        else {
+            res.writeHead(404);
+            res.end();
+        }
+    });
+}
+// ── Tests ───────────────────────────────────────────────────
+describe("LocalChatProvider — Ollama (L8.1)", () => {
+    let server;
+    let port;
+    beforeAll(async () => {
+        server = createMockOllamaServer();
+        await new Promise((resolve) => {
+            server.listen(0, "127.0.0.1", () => resolve());
+        });
+        port = server.address().port;
+    });
+    afterAll(async () => {
+        await new Promise((resolve) => server.close(() => resolve()));
+    });
+    it("streams chat response from Ollama /api/chat", async () => {
+        const config = {
+            provider: "ollama",
+            baseUrl: `http://127.0.0.1:${port}`,
+            chatModel: "llama3",
+            embeddingModel: "nomic-embed-text",
+            embeddingDimensions: 384,
+            maxConcurrency: 2,
+        };
+        const provider = new LocalChatProvider(config);
+        expect(provider.providerName).toBe("ollama");
+        expect(provider.modelId).toBe("llama3");
+        const chunks = [];
+        const response = await provider.streamChat([{ role: "user", content: "Hello" }], [], "You are a helpful assistant.", 1024, (chunk) => chunks.push(chunk));
+        expect(response.text).toBe("Hello world!");
+        expect(response.toolCalls).toHaveLength(0);
+        expect(response.outputTokens).toBe(10);
+        expect(response.inputTokens).toBe(5);
+        const textChunks = chunks.filter((c) => c.type === "text_delta");
+        expect(textChunks).toHaveLength(2);
+        expect(textChunks[0]?.text).toBe("Hello ");
+        expect(textChunks[1]?.text).toBe("world!");
+        expect(chunks[chunks.length - 1]?.type).toBe("done");
+    });
+});
+describe("LocalChatProvider — OpenAI-Compatible (L8.1)", () => {
+    let server;
+    let port;
+    beforeAll(async () => {
+        server = createMockOpenAiServer();
+        await new Promise((resolve) => {
+            server.listen(0, "127.0.0.1", () => resolve());
+        });
+        port = server.address().port;
+    });
+    afterAll(async () => {
+        await new Promise((resolve) => server.close(() => resolve()));
+    });
+    it("streams chat response from OpenAI-compatible SSE endpoint", async () => {
+        const config = {
+            provider: "lm-studio",
+            baseUrl: `http://127.0.0.1:${port}`,
+            chatModel: "llama3",
+            embeddingModel: "nomic-embed-text",
+            embeddingDimensions: 384,
+            maxConcurrency: 2,
+        };
+        const provider = new LocalChatProvider(config);
+        expect(provider.providerName).toBe("lm-studio");
+        const chunks = [];
+        const response = await provider.streamChat([{ role: "user", content: "Hi" }], [], "You are helpful.", 1024, (chunk) => chunks.push(chunk));
+        expect(response.text).toBe("Hi there!");
+        expect(response.toolCalls).toHaveLength(0);
+        const textChunks = chunks.filter((c) => c.type === "text_delta");
+        expect(textChunks).toHaveLength(2);
+        expect(chunks[chunks.length - 1]?.type).toBe("done");
+    });
+});
+describe("toChatToolDefs (L8.1)", () => {
+    it("converts Tool[] to ChatToolDef[]", () => {
+        const tools = [
+            {
+                name: "get_function",
+                description: "Get function details",
+                inputSchema: {
+                    type: "object",
+                    properties: { key: { type: "string" } },
+                    required: ["key"],
+                },
+                isReadOnly: true,
+                requiresPermission: false,
+                execute: async () => ({ content: "" }),
+            },
+        ];
+        const defs = toChatToolDefs(tools);
+        expect(defs).toHaveLength(1);
+        expect(defs[0]?.type).toBe("function");
+        expect(defs[0]?.function.name).toBe("get_function");
+        expect(defs[0]?.function.description).toBe("Get function details");
+        expect(defs[0]?.function.parameters).toEqual(tools[0]?.inputSchema);
+    });
+});
+describe("LocalChatProvider — anthropic-direct (L8.1)", () => {
+    it("throws if no API key configured", async () => {
+        const config = {
+            provider: "anthropic-direct",
+            chatModel: "claude-sonnet-4-20250514",
+            embeddingModel: "nomic-embed-text",
+            embeddingDimensions: 384,
+            maxConcurrency: 2,
+        };
+        const provider = new LocalChatProvider(config);
+        expect(provider.providerName).toBe("anthropic-direct");
+        await expect(provider.streamChat([{ role: "user", content: "Hello" }], [], "System prompt", 1024, () => { })).rejects.toThrow("anthropic-direct requires an API key");
+    });
+});