mdi-llmkit 0.1.0 → 1.0.1

package/dist/tests/gptApi/gptConversation.test.js

@@ -0,0 +1,157 @@
+import { describe, expect, it } from "vitest";
+import { GptConversation } from "../../src/gptApi/gptConversation.js";
+class FakeResponse {
+    output_text;
+    error;
+    incomplete_details;
+    constructor(outputText = "", error = null, incompleteDetails = null) {
+        this.output_text = outputText;
+        this.error = error;
+        this.incomplete_details = incompleteDetails;
+    }
+}
+class FakeResponsesAPI {
+    sideEffects;
+    createCalls;
+    constructor(sideEffects = []) {
+        this.sideEffects = [...sideEffects];
+        this.createCalls = [];
+    }
+    create(kwargs) {
+        this.createCalls.push(kwargs);
+        if (!this.sideEffects.length) {
+            return new FakeResponse();
+        }
+        const next = this.sideEffects.shift();
+        if (next instanceof Error) {
+            throw next;
+        }
+        return next;
+    }
+}
+class FakeOpenAIClient {
+    responses;
+    constructor(sideEffects = []) {
+        this.responses = new FakeResponsesAPI(sideEffects);
+    }
+}
+describe("GptConversation", () => {
+    it("defaults to empty state with no client or model", () => {
+        const conversation = new GptConversation();
+        expect(conversation).toEqual([]);
+        expect(conversation.openaiClient).toBeUndefined();
+        expect(conversation.model).toBeUndefined();
+        expect(conversation.lastReply).toBeNull();
+    });
+    it("assignMessages replaces contents and returns self", () => {
+        const conversation = new GptConversation([{ role: "user", content: "old" }]);
+        const next = [
+            { role: "system", content: "new" },
+            { role: "user", content: "hello" },
+        ];
+        const returned = conversation.assignMessages(next);
+        expect(returned).toBe(conversation);
+        expect(conversation).toEqual(next);
+    });
+    it("clone deep copies messages while preserving client and model refs", () => {
+        const client = new FakeOpenAIClient();
+        const conversation = new GptConversation([
+            {
+                role: "user",
+                content: JSON.stringify({ nested: { x: 1 } }),
+            },
+        ], { openaiClient: client, model: "gpt-custom" });
+        const cloned = conversation.clone();
+        expect(cloned).not.toBe(conversation);
+        expect(cloned).toEqual(conversation);
+        expect(cloned.openaiClient).toBe(client);
+        expect(cloned.model).toBe("gpt-custom");
+    });
+    it("addMessage serializes object content as pretty JSON", () => {
+        const conversation = new GptConversation();
+        conversation.addMessage("user", { a: 1 });
+        expect(conversation[0]).toEqual({
+            role: "user",
+            content: '{\n  "a": 1\n}',
+        });
+    });
+    it("role-specific helpers add expected role labels", () => {
+        const conversation = new GptConversation();
+        conversation.addUserMessage("u");
+        conversation.addAssistantMessage("a");
+        conversation.addSystemMessage("s");
+        conversation.addDeveloperMessage("d");
+        expect(conversation.map((m) => m.role)).toEqual([
+            "user",
+            "assistant",
+            "system",
+            "developer",
+        ]);
+    });
+    it("submit throws if no openai client is configured", async () => {
+        const conversation = new GptConversation([{ role: "user", content: "hello" }]);
+        await expect(conversation.submit()).rejects.toThrow("OpenAI client is not set. Please provide an OpenAI client.");
+    });
+    it("submit appends user message then assistant reply", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse("assistant reply")]);
+        const conversation = new GptConversation([], { openaiClient: client });
+        const result = await conversation.submit("hello");
+        expect(result).toBe("assistant reply");
+        expect(conversation).toEqual([
+            { role: "user", content: "hello" },
+            { role: "assistant", content: "assistant reply" },
+        ]);
+        expect(conversation.lastReply).toBe("assistant reply");
+    });
+    it("submit infers jsonResponse and role from dict-like message", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse('{"ok": true}')]);
+        const conversation = new GptConversation([], { openaiClient: client });
+        const message = {
+            format: { type: "json_object" },
+            role: "developer",
+            content: "Return JSON only.",
+        };
+        const result = await conversation.submit(message, null);
+        expect(result).toEqual({ ok: true });
+        expect(conversation[0]).toEqual({ role: "developer", content: "Return JSON only." });
+        expect(conversation[1]).toEqual({ role: "assistant", content: '{\n  "ok": true\n}' });
+    });
+    it("submit wrapper methods add role and return reply", async () => {
+        const client = new FakeOpenAIClient([
+            new FakeResponse("r1"),
+            new FakeResponse("r2"),
+            new FakeResponse("r3"),
+            new FakeResponse("r4"),
+            new FakeResponse("r5"),
+        ]);
+        const conversation = new GptConversation([], { openaiClient: client });
+        await expect(conversation.submitMessage("system", "m1")).resolves.toBe("r1");
+        await expect(conversation.submitUserMessage("m2")).resolves.toBe("r2");
+        await expect(conversation.submitAssistantMessage("m3")).resolves.toBe("r3");
+        await expect(conversation.submitSystemMessage("m4")).resolves.toBe("r4");
+        await expect(conversation.submitDeveloperMessage("m5")).resolves.toBe("r5");
+        expect(conversation.filter((_, index) => index % 2 === 0).map((m) => m.role)).toEqual([
+            "system",
+            "user",
+            "assistant",
+            "system",
+            "developer",
+        ]);
+    });
+    it("lastReply accessors enforce expected types", () => {
+        const conversation = new GptConversation();
+        conversation.lastReply = "hello";
+        expect(conversation.getLastReplyStr()).toBe("hello");
+        expect(conversation.getLastReplyDict()).toEqual({});
+        conversation.lastReply = { x: 10, nested: { y: 1 } };
+        expect(conversation.getLastReplyStr()).toBe("");
+        const cloned = conversation.getLastReplyDict();
+        expect(cloned).toEqual({ x: 10, nested: { y: 1 } });
+        cloned.nested.y = 2;
+        expect(conversation.lastReply.nested.y).toBe(1);
+        expect(conversation.getLastReplyDictField("x")).toBe(10);
+        expect(conversation.getLastReplyDictField("missing", 99)).toBe(99);
+        conversation.lastReply = "not dict";
+        expect(conversation.getLastReplyDictField("x", 99)).toBeNull();
+    });
+});

package/dist/tests/gptApi/gptSubmit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gptApi/gptSubmit.test.js

@@ -0,0 +1,161 @@
+import { describe, expect, it } from "vitest";
+import { GPT_MODEL_SMART, gptSubmit, } from "../../src/gptApi/functions.js";
+class FakeResponse {
+    output_text;
+    error;
+    incomplete_details;
+    constructor(outputText = "", error = null, incompleteDetails = null) {
+        this.output_text = outputText;
+        this.error = error;
+        this.incomplete_details = incompleteDetails;
+    }
+}
+class FakeResponsesAPI {
+    sideEffects;
+    createCalls;
+    constructor(sideEffects = []) {
+        this.sideEffects = [...sideEffects];
+        this.createCalls = [];
+    }
+    create(kwargs) {
+        this.createCalls.push(kwargs);
+        if (!this.sideEffects.length) {
+            return new FakeResponse();
+        }
+        const next = this.sideEffects.shift();
+        if (next instanceof Error) {
+            throw next;
+        }
+        return next;
+    }
+}
+class FakeOpenAIClient {
+    responses;
+    constructor(sideEffects = []) {
+        this.responses = new FakeResponsesAPI(sideEffects);
+    }
+}
+class OpenAIError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OpenAIError";
+    }
+}
+describe("gptSubmit", () => {
+    it("uses default model and omits text config when json mode is disabled", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse("ok")]);
+        const result = await gptSubmit([{ role: "user", content: "Hello" }], client);
+        expect(result).toBe("ok");
+        expect(client.responses.createCalls).toHaveLength(1);
+        const request = client.responses.createCalls[0];
+        expect(request.model).toBe(GPT_MODEL_SMART);
+        expect("text" in request).toBe(false);
+    });
+    it("prepends datetime system message and keeps user messages after it", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse("ok")]);
+        const messages = [{ role: "user", content: "Hello" }];
+        await gptSubmit(messages, client);
+        const submitted = client.responses.createCalls[0].input;
+        expect(submitted[0].role).toBe("system");
+        expect(submitted[0].content.startsWith("!DATETIME:")).toBe(true);
+        expect(submitted.slice(1)).toEqual(messages);
+    });
+    it("replaces stale datetime messages and keeps other system messages", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse("ok")]);
+        const messages = [
+            { role: "system", content: "!DATETIME: old timestamp" },
+            { role: "system", content: "keep me" },
+            { role: "user", content: "hello" },
+        ];
+        await gptSubmit(messages, client);
+        const submitted = client.responses.createCalls[0].input;
+        const datetimeMessages = submitted.filter((m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith("!DATETIME:"));
+        expect(datetimeMessages).toHaveLength(1);
+        expect(submitted.slice(1)).toEqual(messages.slice(1));
+    });
+    it("supports json_response=true with json_object text format", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse('{"value":1}')]);
+        const result = await gptSubmit([{ role: "user", content: "json" }], client, {
+            jsonResponse: true,
+        });
+        expect(result).toEqual({ value: 1 });
+        const request = client.responses.createCalls[0];
+        expect(request.text).toEqual({ format: { type: "json_object" } });
+    });
+    it("deep copies json schema dict and appends no-unicode note without mutating input", async () => {
+        const schema = {
+            format: {
+                type: "json_schema",
+                name: "answer",
+                description: "Return answer",
+                schema: {
+                    type: "object",
+                    properties: { answer: { type: "string" } },
+                    required: ["answer"],
+                },
+            },
+        };
+        const client = new FakeOpenAIClient([new FakeResponse('{"answer":"ok"}')]);
+        const result = await gptSubmit([{ role: "user", content: "json" }], client, {
+            jsonResponse: schema,
+        });
+        expect(result).toEqual({ answer: "ok" });
+        expect(schema.format.description).toBe("Return answer");
+        const submitted = client.responses.createCalls[0].text;
+        expect(submitted.format.description).toContain("ABSOLUTELY NO UNICODE ALLOWED");
+    });
+    it("parses first json object when response contains trailing json", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse('{"first":1}{"second":2}')]);
+        const result = await gptSubmit([{ role: "user", content: "json" }], client, {
+            jsonResponse: true,
+        });
+        expect(result).toEqual({ first: 1 });
+    });
+    it("retries openai errors and succeeds", async () => {
+        const warnings = [];
+        const client = new FakeOpenAIClient([new OpenAIError("temporary"), new FakeResponse("ok")]);
+        const result = await gptSubmit([{ role: "user", content: "hello" }], client, {
+            retryLimit: 2,
+            retryBackoffTimeSeconds: 0,
+            warningCallback: (message) => warnings.push(message),
+        });
+        expect(result).toBe("ok");
+        expect(client.responses.createCalls).toHaveLength(2);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain("OpenAI API error");
+        expect(warnings[0]).toContain("Retrying (attempt 1 of 2)");
+    });
+    it("retries json decode errors and succeeds", async () => {
+        const warnings = [];
+        const client = new FakeOpenAIClient([new FakeResponse("not json"), new FakeResponse('{"ok":true}')]);
+        const result = await gptSubmit([{ role: "user", content: "hello" }], client, {
+            jsonResponse: true,
+            retryLimit: 2,
+            warningCallback: (message) => warnings.push(message),
+        });
+        expect(result).toEqual({ ok: true });
+        expect(client.responses.createCalls).toHaveLength(2);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain("JSON decode error");
+    });
+    it("throws for malformed response output_text without retry", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse(null)]);
+        await expect(gptSubmit([{ role: "user", content: "hello" }], client, {
+            retryLimit: 5,
+        })).rejects.toBeInstanceOf(TypeError);
+        expect(client.responses.createCalls).toHaveLength(1);
+    });
+    it("throws immediately if jsonResponse string is invalid json", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse('{"unused":true}')]);
+        await expect(gptSubmit([{ role: "user", content: "hello" }], client, {
+            jsonResponse: "{not valid json",
+        })).rejects.toBeInstanceOf(SyntaxError);
+        expect(client.responses.createCalls).toHaveLength(0);
+    });
+    it("throws unknown error when retryLimit is zero", async () => {
+        const client = new FakeOpenAIClient([new FakeResponse("ok")]);
+        await expect(gptSubmit([{ role: "user", content: "hello" }], client, {
+            retryLimit: 0,
+        })).rejects.toThrow("Unknown error occurred in gptSubmit");
+    });
+});

package/dist/tests/gptApi/jsonSchemaFormat.test.d.ts

@@ -0,0 +1 @@
+export {};