llaminate 0.1.0

package/tests/common/matches.js

@@ -0,0 +1,69 @@
+const matchReply = () => ({
+        message: expect.stringMatching(/.+/),
+        result: expect.arrayContaining([
+          expect.objectContaining({
+            role: expect.stringMatching(/^(assistant)$/),
+            content: expect.stringMatching(/.+/)
+          })
+        ]),
+        tokens: expect.objectContaining({
+          input: expect.toBeGreaterThan(0),
+          output: expect.toBeGreaterThan(0),
+          total: expect.toBeGreaterThan(0)
+        }),
+        uuid: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i),
+        // New validation for JSON structure
+        message: expect.stringMatching(/.+/)
+      });
+
+const matchToolReply = (name) => ({
+        message: expect.anything(),
+        result: expect.arrayContaining([
+          expect.objectContaining({
+            role: expect.stringMatching(/^(assistant)$/),
+            tool_calls: expect.arrayContaining([
+              expect.objectContaining({
+                id: expect.stringMatching(/.+/),
+                function: expect.objectContaining({
+                  arguments: expect.stringMatching(/.+/),
+                  name: expect.stringMatching(new RegExp(`^${name}$`))
+                }),
+              })
+            ])
+          }),
+          expect.objectContaining({
+            role: expect.stringMatching(/tool/),
+            name: expect.stringMatching(new RegExp(`^${name}$`)),
+            content: expect.stringMatching(/.+/),
+            tool_call_id: expect.stringMatching(/.+/)
+          }),
+          expect.objectContaining({
+            role: expect.stringMatching(/assistant/),
+            content: expect.stringMatching(/.+/)
+          })
+        ]),
+        tokens: expect.objectContaining({
+          input: expect.toBeGreaterThan(0),
+          output: expect.toBeGreaterThan(0),
+          total: expect.toBeGreaterThan(0)
+        }),
+        uuid: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i)
+      });
+
+const matchSchemaReply = (schema) => ({
+        message: expect.toMatchSchema(schema),
+        result: expect.arrayContaining([
+          expect.objectContaining({
+            role: expect.stringMatching(/^(assistant)$/),
+            content: expect.stringMatching(/.+/)
+          })
+        ]),
+        tokens: expect.objectContaining({
+          input: expect.toBeGreaterThan(0),
+          output: expect.toBeGreaterThan(0),
+          total: expect.toBeGreaterThan(0)
+        }),
+        uuid: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i),
+      });
+
+module.exports = { matchReply, matchToolReply, matchSchemaReply };

package/tests/common/setup.js

@@ -0,0 +1,45 @@
+const Llaminate = require("../../dist/llaminate.min.js").Llaminate;
+require('../extensions/toMatchSchema.js');
+
+const llaminate = new Llaminate({
+  endpoint: process.env.TEST_ENDPOINT,
+  key: process.env.TEST_API_KEY,
+  model: process.env.TEST_MODEL,
+  system: ["You are a sarcastic assistant who answers very briefly and bluntly."],
+  rpm: Number(process.env.TEST_RPM)
+});
+
+const tools = [
+  {
+    function: {
+      name: "get_current_time",
+      description: "Returns the current time in ISO format.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      }
+    },
+    handler: async () => {
+      return new Date().toISOString();
+    }
+  }
+];
+
+const schema = {
+  type: "object",
+  properties: {
+    reply: {
+        type: "string",
+        description: "Your response to the user's query."
+    },
+    thoughts: {
+      type: "string",
+      description: "Your internal thoughts about the user's query."
+    },
+  },
+  required: ["reply", "thoughts"],
+  additionalProperties: false,
+};
+
+module.exports = { Llaminate, llaminate, tools, schema };

package/tests/complete.test.js

@@ -0,0 +1,27 @@
+const { Llaminate, llaminate, config, tools, schema } = require("./common/setup.js");
+const { matchReply, matchToolReply, matchSchemaReply } = require("./common/matches.js");
+
+describe("Completion", () => {
+
+    beforeEach(() => { llaminate.clear(); });
+    afterAll(() => { llaminate.clear(); });
+
+    test("given a question, replies with an answer", async () => {
+        await expect(llaminate.complete("What's the capital of France?"))
+            .resolves.toMatchObject(matchReply());
+    });
+
+    test("given a tool and a relevant question, replies using the tool", async () => {
+        await expect(llaminate.complete("What time is it?", { tools } ))
+            .resolves.toMatchObject(matchToolReply(tools[0].function.name));
+    });
+
+    test("given a schema, replies using that schema", async () => {
+        await expect(llaminate.complete("How many bicycles are there in Beijing?", { schema }))
+            .resolves.toMatchObject(matchSchemaReply(schema));
+    });
+
+    beforeAll(() => { llaminate.clear(); });
+    afterAll(() => { llaminate.clear(); });
+
+});

package/tests/extensions/toMatchSchema.js

@@ -0,0 +1,20 @@
+const Ajv = require("ajv");
+
+function toMatchSchema(obj, schema) {
+    const ajv = new Ajv();
+    const validate = ajv.compile(schema);
+
+    return {
+        message: () => `expected ${this.utils.printReceived(json)} to match schema ${this.utils.printExpected(schema)}`,
+        pass: validate(obj),
+    };
+}
+
+function toBeGreaterThan(received, floor) {
+    return {
+        message: () => `expected ${this.utils.printReceived(received)} to be greater than ${floor}`,
+        pass: received > floor,
+    };
+}
+
+expect.extend({ toMatchSchema, toBeGreaterThan });

package/tests/history.test.js

@@ -0,0 +1,86 @@
+const { Llaminate, llaminate, config, tools, schema } = require("./common/setup.js");
+
+const system = ["Reply in a traditional haiku format."];
+
+const messages = [
+    { role: "user", content: "If clouds were made of candy, what flavor would they be?" },
+    { role: "assistant", content: "Cotton candy. Obviously." },
+    { role: "user", content: "What about rain?" },
+    { role: "assistant", content: "Lemon. Duh." },
+    { role: "user", content: "And snowflakes?" },
+    { role: "assistant", content: "Vanilla. What else?" },
+    { role: "user", content: "What if the moon was made of cheese?" },
+    { role: "assistant", content: "Cheddar. Maybe brie. Happy?" },
+    { role: "user", content: "Would stars be edible too?" },
+    { role: "assistant", content: "Popping candy. Next." },
+    { role: "user", content: "What would the sun taste like?" },
+    { role: "assistant", content: "Cinnamon. Spicy." },
+    { role: "user", content: "If the ocean was a drink, what would it be?" },
+    { role: "assistant", content: "Blue slushie. Salty." },
+    { role: "user", content: "What about the wind?" },
+    { role: "assistant", content: "Mint. Refreshing." },
+    { role: "user", content: "If mountains were desserts, what would they be?" },
+    { role: "assistant", content: "Chocolate cake. Tall." },
+    { role: "user", content: "What about the stars again?" }
+];
+
+describe("History", () => {
+
+    beforeAll(() => { llaminate.clear(); });
+    afterAll(() => { llaminate.clear(); });
+
+    test("given an initial state, the history is correct", async () => {
+        const history = await llaminate.export();
+        await expect(history.length).toBe(1);
+        await expect(history[0]).toMatchObject({
+            role: "system",
+            content: llaminate.config.system[0]
+        });
+    });
+
+    test("given a prompt, the history expands", async () => {
+        const message = "What does the fox say?";
+        await llaminate.complete(message);
+        const history = await llaminate.export();
+        await expect(history.length).toBe(3);
+        await expect(history[0]).toMatchObject({
+            role: "system",
+            content: llaminate.config.system[0]
+        });
+        await expect(history[1]).toMatchObject({
+            role: "user",
+            content: message
+        });
+        await expect(history[2]).toMatchObject({
+            role: "assistant",
+            content: expect.stringMatching(/.+/)
+        });
+    });
+
+    test("given a series of messages, the history is correct", async () => {
+        await llaminate.complete(messages, { system });
+
+        const history = await llaminate.export();
+        await expect(history.length).toBe(messages.length + 2); // + 2 for system message and assistant's final reply
+
+        await expect(history[0]).toMatchObject({ role: "system", content: llaminate.config.system[0] });
+        for (let i = 1; i < messages.length; i++) {
+            await expect(history[i + 1]).toMatchObject(messages[i]);
+        }
+        await expect(history[history.length - 1]).toMatchObject({
+            role: "assistant",
+            content: expect.stringMatching(/.+/)
+        });
+    });
+
+    test("when history is cleared, the history is correct", async () => {
+        await llaminate.clear();
+        const history = await llaminate.export();
+        await expect(history.length).toBe(1);
+        await expect(history[0]).toMatchObject({
+            role: "system",
+            content: llaminate.config.system[0]
+        });
+    });
+
+});

package/tests/stream.test.js

@@ -0,0 +1,67 @@
+const { Llaminate, llaminate, config, tools, schema } = require("./common/setup.js");
+const { matchReply, matchToolReply, matchSchemaReply } = require("./common/matches.js");
+
+describe("Streaming", () => {
+    beforeEach(() => { llaminate.clear(); });
+    afterAll(() => { llaminate.clear(); });
+
+    test("given a question, replies with a stream", async () => {
+        const stream = await llaminate.stream("What's the capital of France?");
+
+        const chunks = [];
+        for await (const chunk of stream) chunks.push(chunk);
+
+        for (let i = 0; i < chunks.length; i++) {
+            expect(chunks[i]).toMatchObject({
+                message: expect.anything(String),
+                uuid: expect.stringMatching(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i)
+            });
+
+            if (i > 0) {
+                // Each chunk's message should contain the previous chunk's message
+                expect(chunks[i].message).toContain(chunks[i - 1].message);
+                // All chunks should have the same UUID
+                expect(chunks[i].uuid).toBe(chunks[0].uuid);
+            }
+
+            if (i < chunks.length - 1) {
+                expect(chunks[i].result).toBeNull();
+                expect(chunks[i].tokens).toBeNull();
+            } else {
+                expect(chunks[i]).toMatchObject(matchReply());
+            }
+        }
+    });
+
+    test("given a tool and a relevant question, replies with a stream and uses the tool", async () => {
+        const stream = await llaminate.stream("What time is it?", { tools });
+
+        const chunks = [];
+        for await (const chunk of stream) chunks.push(chunk);
+
+        expect(chunks.length).toBeGreaterThan(1);
+        expect(chunks[chunks.length - 1]).toMatchObject(matchToolReply(tools[0].function.name));
+    });
+
+    test("given a schema, replies with a stream and uses that schema", async () => {
+        llaminate.clear();
+        const stream = await llaminate.stream("How many bicycles are there in Beijing?", { schema });
+
+        const chunks = [];
+        for await (const chunk of stream) chunks.push(chunk);
+
+        expect(chunks.length).toBeGreaterThan(1);
+        expect(chunks[chunks.length - 1]).toMatchObject(matchSchemaReply(schema));
+    });
+
+    test("given a schema, a tool and a relevant question, uses the tool and replies with a stream adhering to the schema", async () => {
+        const stream = await llaminate.stream("What time is it?", { schema, tools });
+
+        const chunks = [];
+        for await (const chunk of stream) chunks.push(chunk);
+
+        expect(chunks.length).toBeGreaterThan(1);
+        expect(chunks[chunks.length - 1]).toMatchObject(matchToolReply(tools[0].function.name));
+    });
+
+});

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "outDir": "dist",
+    "target": "es2018",
+    "module": "CommonJS",
+    "declaration": true,
+    "strict": false
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}