🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
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",
});
});
});