@unerr-ai/unerr 0.1.5 → 0.1.7

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

@@ -1,105 +0,0 @@
-/**
- * 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

@@ -1,162 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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

@@ -1,170 +0,0 @@
-/**
- * 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");
-    });
-});