release: WRNexusJS 0.8.0

2026-08-02 23:18:51 +05:30
parent 87507edf59
commit 586a6db8ff
625 changed files with 243608 additions and 11210 deletions
@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test";
+import {
+  aiRateLimiter,
+  createRagPipeline,
+  evaluateAI,
+  googleAIProvider,
+  guardedProvider,
+  localAIProvider,
+  maxPromptLength,
+  memoryConversationStore,
+  memoryVectorStore,
+  openAIProvider,
+  promptTemplate,
+} from "../src/platform.ts";
+
+describe("AI platform", () => {
+  test("adapts OpenAI, Google and local providers", async () => {
+    const openFetch = (async () =>
+      Response.json({
+        model: "gpt",
+        choices: [{ message: { content: "hello" }, finish_reason: "stop" }],
+        usage: { total_tokens: 3 },
+      })) as unknown as typeof fetch;
+    expect(
+      (await openAIProvider({ model: "gpt", apiKey: "key", fetch: openFetch }).generate("hi"))
+        .value,
+    ).toBe("hello");
+    const googleFetch = (async () =>
+      Response.json({
+        candidates: [{ content: { parts: [{ text: "hola" }] } }],
+        usageMetadata: { totalTokenCount: 2 },
+      })) as unknown as typeof fetch;
+    expect(
+      (
+        await googleAIProvider({ model: "gemini", apiKey: "key", fetch: googleFetch }).generate(
+          "hi",
+        )
+      ).value,
+    ).toBe("hola");
+    expect(
+      (await localAIProvider({ model: "llama", fetch: openFetch }).generate("hi")).provider,
+    ).toBe("local");
+  });
+
+  test("indexes and retrieves a RAG answer", async () => {
+    const store = memoryVectorStore<{ source: string }>();
+    const embeddings = {
+      name: "test",
+      embed: async (values: string[]) => ({
+        vectors: values.map((value) => (value.includes("Bun") ? [1, 0] : [0, 1])),
+      }),
+    };
+    const rag = createRagPipeline({
+      embeddings,
+      store,
+      generate: async (prompt) => ({
+        value: prompt.includes("fast") ? "Bun [1]" : "none",
+        provider: "test",
+      }),
+    });
+    await rag.index([
+      { id: "bun", text: "Bun is fast", metadata: { source: "docs" } },
+      { id: "other", text: "Other", metadata: { source: "other" } },
+    ]);
+    const result = await rag.ask("Bun runtime");
+    expect(result.value).toBe("Bun [1]");
+    expect(result.sources[0]?.id).toBe("bun");
+  });
+
+  test("persists conversations, renders prompts, guards and rate limits", async () => {
+    const conversations = memoryConversationStore(2);
+    await conversations.append("one", [
+      { role: "user", content: "a" },
+      { role: "assistant", content: "b" },
+      { role: "user", content: "c" },
+    ]);
+    expect(await conversations.load("one")).toHaveLength(2);
+    expect(promptTemplate("Hello {{name}}")({ name: "Wire" })).toBe("Hello Wire");
+    const provider = guardedProvider(
+      { name: "test", generate: async () => ({ value: "ok", provider: "test" }) },
+      [maxPromptLength(3)],
+    );
+    await expect(provider.generate("long")).rejects.toThrow("guardrail");
+    const limit = aiRateLimiter({ limit: 1, windowMs: 100, now: () => 0 });
+    expect(limit("u").allowed).toBe(true);
+    expect(limit("u").allowed).toBe(false);
+  });
+
+  test("evaluates model output", async () => {
+    const report = await evaluateAI(
+      [{ name: "answer", prompt: "question", expected: "42" }],
+      async () => "42",
+    );
+    expect(report.score).toBe(1);
+  });
+});