@garrix82/reactgenie-dsl 1.0.1 → 1.0.2

package/lib/nl/__test__/nl-parser-openai-parity.test.ts

@@ -1,381 +0,0 @@
-import { NlParser } from "../nl-parser";
-import { PromptGen } from "../prompt-gen";
-
-const promptStub: PromptGen = {
-  prompt: () => "legacy prompt",
-  zero_shot_prompt: () => "filtered prompt",
-  response_prompt: () => "respond prompt",
-};
-
-const promptWithBroadFallback = {
-  ...promptStub,
-  zero_shot_prompt_broad: () => "broad prompt",
-} as PromptGen & { zero_shot_prompt_broad: (user_utterance: string) => string };
-
-describe("NlParser OpenAI parity", () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test("parse sends dsl_command json_schema and extracts command JSON", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{ message: { content: JSON.stringify({ command: "Task.run()" }) } }],
-          usage: { prompt_tokens: 8, completion_tokens: 3, total_tokens: 11 },
-        }),
-        { status: 200, headers: { "content-type": "application/json" } }
-      )
-    ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.parse("run task")).resolves.toBe("Task.run()");
-
-    const [, init] = (global.fetch as jest.Mock).mock.calls[0] as [string, any];
-    const body = JSON.parse(String(init.body));
-    expect(body.model).toBe("gpt-4o-mini");
-    expect(body.response_format?.json_schema?.name).toBe("dsl_command");
-  });
-
-  test("parse retries strict=false then strict=true on filtered prompt", async () => {
-    global.fetch = jest
-      .fn()
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            choices: [{ message: { content: "{}" } }],
-            usage: {},
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      )
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            choices: [{ message: { content: JSON.stringify({ command: "Task.run()" }) } }],
-            usage: {},
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.parse("run task")).resolves.toBe("Task.run()");
-
-    const body1 = JSON.parse(String((global.fetch as jest.Mock).mock.calls[0][1].body));
-    const body2 = JSON.parse(String((global.fetch as jest.Mock).mock.calls[1][1].body));
-    expect(body1.response_format.json_schema.strict).toBe(false);
-    expect(body2.response_format.json_schema.strict).toBe(true);
-  });
-
-  test("parse does not use broad prompt variants", async () => {
-    global.fetch = (
-      jest
-        .fn()
-        .mockResolvedValueOnce(
-          new Response(
-            JSON.stringify({
-              choices: [{ message: { content: "{}" } }],
-              usage: {},
-            }),
-            { status: 200, headers: { "content-type": "application/json" } }
-          )
-        )
-        .mockResolvedValueOnce(
-          new Response(
-            JSON.stringify({
-              choices: [{ message: { content: "{}" } }],
-              usage: {},
-            }),
-            { status: 200, headers: { "content-type": "application/json" } }
-          )
-        )
-    ) as any;
-
-    const parser = new NlParser(
-      promptWithBroadFallback,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.parse("run task")).rejects.toThrow();
-
-    const body1 = JSON.parse(String((global.fetch as jest.Mock).mock.calls[0][1].body));
-    const body2 = JSON.parse(String((global.fetch as jest.Mock).mock.calls[1][1].body));
-    expect(global.fetch).toHaveBeenCalledTimes(2);
-    expect(body1.messages[0].content).toBe("filtered prompt");
-    expect(body2.messages[0].content).toBe("filtered prompt");
-  });
-
-  test("parse repairs one invalid command after semantic validation fails", async () => {
-    const validateCommand = jest
-      .fn<Promise<void>, [string]>()
-      .mockImplementation(async (command: string) => {
-        if (command === 'Task.run(field: "name")') {
-          throw new Error(
-            "Invalid DSL: matching(field: ...) requires a dotted accessor such as .name, but received string."
-          );
-        }
-      });
-
-    global.fetch = jest
-      .fn()
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            choices: [
-              {
-                message: {
-                  content: JSON.stringify({ command: 'Task.run(field: "name")' }),
-                },
-              },
-            ],
-            usage: {},
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      )
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            choices: [{ message: { content: JSON.stringify({ command: "Task.run(field: .name)" }) } }],
-            usage: {},
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini",
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      validateCommand,
-      { statefulValidationRetry: false }
-    );
-
-    await expect(parser.parse("run task")).resolves.toBe("Task.run(field: .name)");
-    expect(validateCommand).toHaveBeenCalledTimes(2);
-    expect(validateCommand).toHaveBeenNthCalledWith(1, 'Task.run(field: "name")');
-    expect(validateCommand).toHaveBeenNthCalledWith(2, "Task.run(field: .name)");
-
-    const repairBody = JSON.parse(String((global.fetch as jest.Mock).mock.calls[1][1].body));
-    expect(repairBody.messages[0].content).toBe("filtered prompt");
-    expect(repairBody.messages[1].content).toBe('Task.run(field: "name")');
-    expect(repairBody.messages[2].content).toContain("The previous DSL command is invalid.");
-    expect(repairBody.messages[2].content).toContain("requires a dotted accessor");
-  });
-
-  test("parse uses Responses API state for validation retry when feature flag is enabled", async () => {
-    const validateCommand = jest
-      .fn<Promise<void>, [string]>()
-      .mockImplementation(async (command: string) => {
-        if (command === 'Task.run(field: "name")') {
-          throw new Error(
-            "Invalid DSL: matching(field: ...) requires a dotted accessor such as .name, but received string."
-          );
-        }
-      });
-
-    global.fetch = jest
-      .fn()
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            id: "resp_initial",
-            output_text: JSON.stringify({ command: 'Task.run(field: "name")' }),
-            usage: { input_tokens: 12, output_tokens: 4, total_tokens: 16 },
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      )
-      .mockResolvedValueOnce(
-        new Response(
-          JSON.stringify({
-            id: "resp_repair",
-            output_text: JSON.stringify({ command: "Task.run(field: .name)" }),
-            usage: { input_tokens: 5, output_tokens: 3, total_tokens: 8 },
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://proxy.example.com/openai/v1",
-      "gpt-4.1-mini",
-      undefined,
-      undefined,
-      undefined,
-      undefined,
-      validateCommand,
-      { statefulValidationRetry: true }
-    );
-
-    await expect(parser.parse("run task")).resolves.toBe("Task.run(field: .name)");
-
-    expect(global.fetch).toHaveBeenCalledTimes(2);
-    const [initialUrl, initialInit] = (global.fetch as jest.Mock).mock.calls[0] as [string, any];
-    const [repairUrl, repairInit] = (global.fetch as jest.Mock).mock.calls[1] as [string, any];
-    const initialBody = JSON.parse(String(initialInit.body));
-    const repairBody = JSON.parse(String(repairInit.body));
-
-    expect(initialUrl).toBe("https://proxy.example.com/openai/v1/responses");
-    expect(repairUrl).toBe("https://proxy.example.com/openai/v1/responses");
-    expect(initialBody.store).toBe(true);
-    expect(initialBody.input[0].content[0].text).toBe("filtered prompt");
-    expect(repairBody.previous_response_id).toBe("resp_initial");
-    expect(repairBody.input[0].content[0].text).toContain("The previous DSL command is invalid.");
-    expect(repairBody.input[0].content[0].text).toContain("requires a dotted accessor");
-    expect(repairBody.input[0].content[0].text).not.toContain("filtered prompt");
-  });
-
-  test("parse throws after filtered prompt strict retries fail", async () => {
-    global.fetch = jest
-      .fn()
-      .mockResolvedValue(
-        new Response(
-          JSON.stringify({
-            choices: [{ message: { content: "{}" } }],
-            usage: {},
-          }),
-          { status: 200, headers: { "content-type": "application/json" } }
-        )
-      ) as any;
-
-    const parser = new NlParser(
-      promptWithBroadFallback,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.parse("run task")).rejects.toThrow(
-      "OpenAI parse failed for filtered prompt"
-    );
-
-    expect(global.fetch).toHaveBeenCalledTimes(2);
-
-    const requestBodies = (global.fetch as jest.Mock).mock.calls.map(([, init]) =>
-      JSON.parse(String(init.body))
-    );
-    expect(requestBodies.map((body) => body.messages[0].content)).toEqual([
-      "filtered prompt",
-      "filtered prompt",
-    ]);
-    expect(requestBodies.map((body) => body.response_format.json_schema.strict)).toEqual([
-      false,
-      true,
-    ]);
-  });
-
-  test("respond sends agent_response json_schema and normalizes payload", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{
-            message: {
-              content: JSON.stringify({
-                minimalText: "Done now",
-                fullText: "Done: Task.run()",
-                type: "success",
-                shouldSpeak: true,
-              }),
-            },
-          }],
-          usage: {},
-        }),
-        { status: 200, headers: { "content-type": "application/json" } }
-      )
-    ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.respond("run task", "Task.run()", "ok")).resolves.toEqual({
-      minimalText: "Done now",
-      fullText: "Done: Task.run()",
-      type: "success",
-      shouldSpeak: true,
-    });
-
-    const [, init] = (global.fetch as jest.Mock).mock.calls[0] as [string, any];
-    const body = JSON.parse(String(init.body));
-    expect(body.response_format?.json_schema?.name).toBe("agent_response");
-  });
-
-  test("respond falls back safely when OpenAI returns invalid JSON", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{ message: { content: "not-json" } }],
-          usage: {},
-        }),
-        { status: 200, headers: { "content-type": "application/json" } }
-      )
-    ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(parser.respond("run task", "Task.run()", "ok")).resolves.toEqual(
-      expect.objectContaining({ type: "success", shouldSpeak: true })
-    );
-  });
-
-  test("respond falls back safely when the transport fails", async () => {
-    global.fetch = jest.fn().mockRejectedValue(new Error("socket hang up")) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await expect(
-      parser.respond("run task", "Task.run()", "error: network failed")
-    ).resolves.toEqual({
-      minimalText: "Retry task",
-      fullText:
-        "I couldn't complete that request. Please try rephrasing or checking the target item.",
-      type: "error",
-      shouldSpeak: true,
-    });
-  });
-
-  test("constructor rejects an empty semantic model", () => {
-    expect(
-      () => new NlParser(promptStub, "token", "https://api.openai.com/v1", "   ")
-    ).toThrow("semanticModel / SEMANTIC_MODEL");
-  });
-});

package/lib/nl/__test__/nl-parser-openai-sampling.test.ts

@@ -1,73 +0,0 @@
-import { NlParser } from "../nl-parser";
-import { PromptGen } from "../prompt-gen";
-
-const promptStub: PromptGen = {
-  prompt: () => "legacy prompt",
-  zero_shot_prompt: () => "parse prompt",
-  response_prompt: () => "respond prompt",
-};
-
-describe("NlParser OpenAI sampling", () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test("parse uses the standard sampling profile", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{ message: { content: JSON.stringify({ command: "Task.run()" }) } }],
-          usage: {},
-        }),
-        { status: 200, headers: { "content-type": "application/json" } }
-      )
-    ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await parser.parse("run task");
-
-    const [, init] = (global.fetch as jest.Mock).mock.calls[0] as [string, any];
-    const body = JSON.parse(String(init.body));
-    expect(body.temperature).toBe(0.2);
-    expect(body.top_p).toBe(1);
-    expect(body.frequency_penalty).toBe(0);
-    expect(body.presence_penalty).toBe(0);
-  });
-
-  test("parseGpt4 uses the same sampling profile", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{ message: { content: JSON.stringify({ command: "Task.run()" }) } }],
-          usage: {},
-        }),
-        { status: 200, headers: { "content-type": "application/json" } }
-      )
-    ) as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "token",
-      "https://api.openai.com/v1",
-      "gpt-4o-mini"
-    );
-
-    await parser.parseGpt4("run task");
-
-    const [, init] = (global.fetch as jest.Mock).mock.calls[0] as [string, any];
-    const body = JSON.parse(String(init.body));
-    expect(body.temperature).toBe(0.2);
-    expect(body.top_p).toBe(1);
-    expect(body.frequency_penalty).toBe(0);
-    expect(body.presence_penalty).toBe(0);
-  });
-});

package/lib/nl/__test__/nl-parser-openai-transport.test.ts

@@ -1,79 +0,0 @@
-import { NlParser } from "../nl-parser";
-import { PromptGen } from "../prompt-gen";
-
-function toHeaderRecord(headers: any): Record<string, string> {
-  if (!headers) return {};
-  if (typeof headers.entries === "function") {
-    return Object.fromEntries(
-      Array.from(headers.entries()).map(([key, value]) => [
-        String(key).toLowerCase(),
-        String(value),
-      ])
-    );
-  }
-  return Object.fromEntries(
-    Object.entries(headers).map(([key, value]) => [
-      String(key).toLowerCase(),
-      String(value),
-    ])
-  );
-}
-
-const promptStub: PromptGen = {
-  prompt: () => "legacy prompt",
-  zero_shot_prompt: () => "parse prompt",
-  response_prompt: () => "respond prompt",
-};
-
-describe("NlParser transport", () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test("uses proxy chat completions endpoint without sdk stainless headers", async () => {
-    const fetchMock = jest.fn().mockResolvedValue(
-      new Response(
-        JSON.stringify({
-          choices: [{ message: { content: JSON.stringify({ command: "Task.run()" }) } }],
-          usage: { prompt_tokens: 12, completion_tokens: 3, total_tokens: 15 },
-        }),
-        {
-          status: 200,
-          headers: { "content-type": "application/json" },
-        }
-      )
-    );
-    global.fetch = fetchMock as any;
-
-    const parser = new NlParser(
-      promptStub,
-      "proxy-token",
-      "https://proxy.example.com/openai/v1",
-      "gpt-4o-mini"
-    );
-
-    const parsed = await parser.parse("run task");
-
-    expect(parsed).toBe("Task.run()");
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-
-    const [url, init] = fetchMock.mock.calls[0] as [string, any];
-    expect(String(url)).toBe("https://proxy.example.com/openai/v1/chat/completions");
-    expect(init?.method).toBe("POST");
-
-    const headers = toHeaderRecord(init?.headers);
-    expect(headers.authorization).toBe("Bearer proxy-token");
-    expect(headers["x-genie-provider"]).toBe("openai");
-    expect(
-      Object.keys(headers).some((key) => key.startsWith("x-stainless-"))
-    ).toBe(false);
-
-    const body = JSON.parse(String(init?.body || "{}"));
-    expect(body.model).toBe("gpt-4o-mini");
-    expect(body.response_format?.type).toBe("json_schema");
-    expect(body.response_format?.json_schema?.name).toBe("dsl_command");
-  });
-});

package/lib/nl/__test__/nl-parser-utils.test.ts

@@ -1,98 +0,0 @@
-import {
-  buildFallbackAgentResponse,
-  createJsonChatCompletion,
-  extractStructuredAgentResponse,
-  extractStructuredCommand,
-  normalizeAgentResponse,
-  normalizeBaseUrl,
-} from "../nl-parser-utils";
-
-describe("nl-parser utils", () => {
-  const originalFetch = global.fetch;
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    jest.restoreAllMocks();
-  });
-
-  test("extractStructuredCommand returns null for invalid or missing command payloads", () => {
-    expect(extractStructuredCommand("not-json")).toBeNull();
-    expect(extractStructuredCommand(JSON.stringify({}))).toBeNull();
-    expect(extractStructuredCommand(JSON.stringify({ command: 7 }))).toBeNull();
-  });
-
-  test("extractStructuredAgentResponse returns null for invalid payload shapes", () => {
-    expect(extractStructuredAgentResponse("not-json")).toBeNull();
-    expect(extractStructuredAgentResponse(JSON.stringify("done"))).toBeNull();
-    expect(extractStructuredAgentResponse(JSON.stringify(null))).toBeNull();
-  });
-
-  test("normalizeAgentResponse applies defaults and trims oversized values", () => {
-    expect(
-      normalizeAgentResponse({
-        minimalText: "  this is too long for speech output  ",
-        fullText: "",
-        type: "unsupported" as any,
-      })
-    ).toEqual({
-      minimalText: "this is",
-      fullText: "this is too long for speech output",
-      type: "info",
-      shouldSpeak: true,
-    });
-  });
-
-  test("buildFallbackAgentResponse returns an error payload for failure contexts", () => {
-    expect(buildFallbackAgentResponse("Task.run()", "Failed to update item")).toEqual({
-      minimalText: "Retry task",
-      fullText:
-        "I couldn't complete that request. Please try rephrasing or checking the target item.",
-      type: "error",
-      shouldSpeak: true,
-    });
-  });
-
-  test("normalizeBaseUrl strips trailing slashes", () => {
-    expect(normalizeBaseUrl("https://proxy.example.com/openai/v1///")).toBe(
-      "https://proxy.example.com/openai/v1"
-    );
-  });
-
-  test("createJsonChatCompletion throws a detailed error for non-ok JSON responses", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response(JSON.stringify({ error: { message: "bad request" } }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      })
-    ) as any;
-
-    await expect(
-      createJsonChatCompletion({
-        endpoint: "https://proxy.example.com/openai/v1/chat/completions",
-        apiKey: "token",
-        body: { model: "gpt-4o-mini" },
-        requestLabel: "OpenAI-compatible request failed",
-        invalidPayloadLabel: "invalid payload",
-      })
-    ).rejects.toThrow("OpenAI-compatible request failed (400): {\"message\":\"bad request\"}");
-  });
-
-  test("createJsonChatCompletion throws for invalid successful payloads", async () => {
-    global.fetch = jest.fn().mockResolvedValue(
-      new Response("not-json", {
-        status: 200,
-        headers: { "content-type": "application/json" },
-      })
-    ) as any;
-
-    await expect(
-      createJsonChatCompletion({
-        endpoint: "https://proxy.example.com/openai/v1/chat/completions",
-        apiKey: "token",
-        body: { model: "gpt-4o-mini" },
-        requestLabel: "OpenAI-compatible request failed",
-        invalidPayloadLabel: "OpenAI-compatible endpoint returned an invalid JSON payload",
-      })
-    ).rejects.toThrow("OpenAI-compatible endpoint returned an invalid JSON payload");
-  });
-});