Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

10.0 KB
Raw Blame
import { NextRequest } from "next/server";
import type * as SharedServer from "@langfuse/shared/src/server";
import { beforeEach, describe, expect, it, vi } from "vitest";

const mocks = vi.hoisted(() => ({
  session: vi.fn(),
  createOutput: vi.fn(),
  createToolSet: vi.fn(),
  findConnection: vi.fn(),
  generate: vi.fn(),
  mapLegacyParams: vi.fn(),
  stream: vi.fn(),
}));

vi.mock("@/src/env.mjs", () => ({
  env: {
    LANGFUSE_BLOCKED_USERIDS_CHATCOMPLETION: new Map(),
    NEXT_PUBLIC_DEMO_PROJECT_ID: "demo-project",
  },
}));

vi.mock("@/src/server/auth", () => ({
  getServerAuthSessionForRequest: mocks.session,
}));

vi.mock("@opentelemetry/api", () => ({
  context: {
    with: (_context: unknown, callback: () => unknown) => callback(),
  },
}));

vi.mock("@langfuse/shared/src/server", async (importOriginal) => {
  const actual = await importOriginal<typeof SharedServer>();

  return {
    ...actual,
    LLMApiKeySchema: {
      safeParse: (connection: unknown) => ({ success: true, data: connection }),
    },
    contextWithLangfuseProps: vi.fn(() => ({})),
    createLLMOutput: mocks.createOutput,
    createLLMToolSet: mocks.createToolSet,
    generateLLMText: mocks.generate,
    mapLegacyLLMCompletionParams: mocks.mapLegacyParams,
    resolveLlmApiKey: mocks.findConnection,
    streamLLMText: mocks.stream,
  };
});

import chatCompletionHandler from "@/src/features/playground/server/chatCompletionHandler";
import { LLMValidationError } from "@langfuse/shared/src/server";

const AISDK_ERROR_MARKER = Symbol.for("vercel.ai.error");
const API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");

function createAiSdkError(name: string, message: string): Error {
  const error = new Error(message);
  error.name = name;
  Object.assign(error, { [AISDK_ERROR_MARKER]: true });
  return error;
}

function createProviderApiError(message: string, statusCode: number): Error {
  const error = createAiSdkError("AI_APICallError", message);
  Object.assign(error, {
    [API_CALL_ERROR_MARKER]: true,
    statusCode,
    url: "https://api.example.com/v1/messages",
    isRetryable: false,
  });
  return error;
}

const baseBody = {
  projectId: "project-1",
  messages: [{ role: "user", type: "user", content: "Hello" }],
  modelParams: {
    provider: "openai",
    adapter: "openai",
    model: "gpt-4.1",
  },
  streaming: false,
};

function createRequest(body: Record<string, unknown>) {
  return new NextRequest("http://localhost/api/chatCompletion", {
    method: "POST",
    body: JSON.stringify(body),
    headers: { "Content-Type": "application/json" },
  });
}

function createSession(projectId = baseBody.projectId, admin = false) {
  return {
    user: {
      id: "user-1",
      admin,
      organizations: [{ projects: [{ id: projectId, role: "ADMIN" }] }],
    },
  };
}

describe("chatCompletionHandler", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mocks.session.mockResolvedValue(createSession());
    mocks.findConnection.mockResolvedValue({
      id: "connection-1",
      secretKey: "encrypted-key",
    });
    mocks.mapLegacyParams.mockReturnValue({
      model: { adapter: "openai", id: "gpt-4.1" },
      connection: { secretKey: "encrypted-key" },
      messages: [{ role: "user", content: "Hello" }],
    });
  });

  it("blocks demo project admins before resolving credentials or calling a model", async () => {
    const projectId = "demo-project";
    mocks.session.mockResolvedValue(createSession(projectId));
    mocks.generate.mockResolvedValue({ text: "Hello back", finalStep: {} });

    const response = await chatCompletionHandler(
      createRequest({ ...baseBody, projectId }),
    );

    expect(response.status).toBe(403);
    expect(mocks.findConnection).not.toHaveBeenCalled();
    expect(mocks.generate).not.toHaveBeenCalled();
    expect(mocks.stream).not.toHaveBeenCalled();
  });

  it("allows internal admins to run demo completions", async () => {
    const projectId = "demo-project";
    mocks.session.mockResolvedValue(createSession(projectId, true));
    mocks.generate.mockResolvedValue({ text: "Hello back", finalStep: {} });

    const response = await chatCompletionHandler(
      createRequest({ ...baseBody, projectId }),
    );

    expect(response.status).toBe(200);
    expect(mocks.generate).toHaveBeenCalledOnce();
  });

  it("maps a native text result to the existing playground JSON response", async () => {
    mocks.generate.mockResolvedValue({
      text: "Hello back",
      finalStep: { reasoningText: "A short reason" },
    });

    const response = await chatCompletionHandler(createRequest(baseBody));

    await expect(response.json()).resolves.toEqual({
      content: "Hello back",
      reasoning: "A short reason",
    });
    expect(mocks.generate).toHaveBeenCalledWith({
      model: { adapter: "openai", id: "gpt-4.1" },
      connection: { secretKey: "encrypted-key" },
      messages: [{ role: "user", content: "Hello" }],
      timeout: 95_000,
    });
  });

  it("returns only the generated structured output", async () => {
    const output = { kind: "object-output" };
    mocks.createOutput.mockReturnValue(output);
    mocks.generate.mockResolvedValue({ output: { answer: 42 } });

    const response = await chatCompletionHandler(
      createRequest({
        ...baseBody,
        structuredOutputSchema: {
          type: "object",
          properties: { answer: { type: "number" } },
          required: ["answer"],
        },
      }),
    );

    await expect(response.json()).resolves.toEqual({ answer: 42 });
    expect(mocks.generate).toHaveBeenCalledWith(
      expect.objectContaining({ output }),
    );
  });

  it("maps native tool calls to the legacy playground tool_calls shape", async () => {
    const toolSet = { lookup: { description: "Look up a value" } };
    mocks.createToolSet.mockReturnValue(toolSet);
    mocks.generate.mockResolvedValue({
      text: "",
      finalStep: { reasoningText: "I need the tool" },
      toolCalls: [
        {
          toolName: "lookup",
          toolCallId: "call-1",
          input: { key: "value" },
        },
      ],
    });

    const response = await chatCompletionHandler(
      createRequest({
        ...baseBody,
        tools: [
          {
            name: "lookup",
            description: "Look up a value",
            parameters: {
              type: "object",
              properties: { key: { type: "string" } },
              required: ["key"],
            },
          },
        ],
      }),
    );

    await expect(response.json()).resolves.toEqual({
      content: "",
      tool_calls: [{ name: "lookup", id: "call-1", args: { key: "value" } }],
      reasoning: "I need the tool",
    });
    expect(mocks.generate).toHaveBeenCalledWith(
      expect.objectContaining({ tools: toolSet }),
    );
  });

  it("preserves extracted tool names for provider validation", async () => {
    const toolSet = { "ns:get_time": { description: "Get the time" } };
    mocks.createToolSet.mockReturnValue(toolSet);
    mocks.generate.mockResolvedValue({
      text: "",
      finalStep: {},
      toolCalls: [],
    });

    const toolDefinition = {
      name: "ns:get_time",
      description: "Get the time",
      parameters: { type: "object", properties: {} },
    };
    const response = await chatCompletionHandler(
      createRequest({
        ...baseBody,
        tools: [toolDefinition],
      }),
    );

    expect(response.status).toBe(200);
    expect(mocks.createToolSet).toHaveBeenCalledWith([toolDefinition]);
    expect(mocks.generate).toHaveBeenCalledWith(
      expect.objectContaining({ tools: toolSet }),
    );
  });

  it("preserves the text/plain streaming response", async () => {
    const textStream = new ReadableStream<string>({
      start(controller) {
        controller.enqueue("streamed text");
        controller.close();
      },
    });
    mocks.stream.mockResolvedValue({ textStream });

    const response = await chatCompletionHandler(
      createRequest({ ...baseBody, streaming: true }),
    );

    await expect(response.text()).resolves.toBe("streamed text");
    expect(response.headers.get("content-type")).toBe(
      "text/plain; charset=utf-8",
    );
    expect(mocks.generate).not.toHaveBeenCalled();
    expect(mocks.stream).toHaveBeenCalledWith({
      model: { adapter: "openai", id: "gpt-4.1" },
      connection: { secretKey: "encrypted-key" },
      messages: [{ role: "user", content: "Hello" }],
    });
  });

  it("preserves terminal LLM configuration status codes", async () => {
    const error = new LLMValidationError({
      code: "invalid-request",
      message: "Unsupported provider options: unknown_parameter",
    });
    mocks.generate.mockRejectedValue(error);

    const response = await chatCompletionHandler(createRequest(baseBody));

    expect(response.status).toBe(400);
    await expect(response.json()).resolves.toEqual({
      error: "LLMValidationError",
      message: "Unsupported provider options: unknown_parameter",
    });
  });

  it("maps structured-output AI SDK failures to 400 instead of 500", async () => {
    mocks.createOutput.mockReturnValue({ kind: "object-output" });
    mocks.generate.mockRejectedValue(
      createAiSdkError(
        "AI_NoOutputGeneratedError",
        "The model did not generate output",
      ),
    );

    const response = await chatCompletionHandler(
      createRequest({
        ...baseBody,
        structuredOutputSchema: {
          type: "object",
          properties: { answer: { type: "number" } },
          required: ["answer"],
        },
      }),
    );

    expect(response.status).toBe(400);
    await expect(response.json()).resolves.toEqual({
      error: "AI_NoOutputGeneratedError",
      message: "The model did not generate output",
    });
  });

  it("preserves upstream provider 5xx status codes", async () => {
    mocks.generate.mockRejectedValue(
      createProviderApiError("Provider unavailable", 500),
    );

    const response = await chatCompletionHandler(createRequest(baseBody));

    expect(response.status).toBe(500);
    await expect(response.json()).resolves.toEqual({
      error: "AI_APICallError",
      message: "Provider unavailable",
    });
  });
});