f84c4c89f5
The openai-completions provider now calls .withResponse() on the
create() result to surface HTTP status/headers for the new onResponse
hook (d131fcd4). The FakeOpenAI test mock only returned an async
iterable, so 4 tests in openai-completions-tool-choice.test.ts that
actually consume the stream failed with "withResponse is not a function".
Updated the mock to return a Promise augmented with .withResponse()
resolving to { data: <async iterable>, response: { status, headers } }.
closes #3304
561 lines
13 KiB
TypeScript
561 lines
13 KiB
TypeScript
import { Type } from "@sinclair/typebox";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import { getModel } from "../src/models.js";
|
|
import { streamSimple } from "../src/stream.js";
|
|
import type { Tool } from "../src/types.js";
|
|
|
|
const mockState = vi.hoisted(() => ({
|
|
lastParams: undefined as unknown,
|
|
chunks: undefined as
|
|
| Array<null | {
|
|
id?: string;
|
|
choices?: Array<{ delta: Record<string, unknown>; finish_reason: string | null; usage?: unknown }>;
|
|
usage?: {
|
|
prompt_tokens: number;
|
|
completion_tokens: number;
|
|
prompt_tokens_details: { cached_tokens: number; cache_write_tokens?: number };
|
|
completion_tokens_details: { reasoning_tokens: number };
|
|
};
|
|
}>
|
|
| undefined,
|
|
}));
|
|
|
|
vi.mock("openai", () => {
|
|
class FakeOpenAI {
|
|
chat = {
|
|
completions: {
|
|
create: (params: unknown) => {
|
|
mockState.lastParams = params;
|
|
const stream = {
|
|
async *[Symbol.asyncIterator]() {
|
|
const chunks = mockState.chunks ?? [
|
|
{
|
|
choices: [{ delta: {}, finish_reason: "stop" }],
|
|
usage: {
|
|
prompt_tokens: 1,
|
|
completion_tokens: 1,
|
|
prompt_tokens_details: { cached_tokens: 0 },
|
|
completion_tokens_details: { reasoning_tokens: 0 },
|
|
},
|
|
},
|
|
];
|
|
for (const chunk of chunks) {
|
|
yield chunk;
|
|
}
|
|
},
|
|
};
|
|
const promise = Promise.resolve(stream) as Promise<typeof stream> & {
|
|
withResponse: () => Promise<{
|
|
data: typeof stream;
|
|
response: { status: number; headers: Headers };
|
|
}>;
|
|
};
|
|
promise.withResponse = async () => ({
|
|
data: stream,
|
|
response: { status: 200, headers: new Headers() },
|
|
});
|
|
return promise;
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
return { default: FakeOpenAI };
|
|
});
|
|
|
|
describe("openai-completions tool_choice", () => {
|
|
beforeEach(() => {
|
|
mockState.lastParams = undefined;
|
|
mockState.chunks = undefined;
|
|
});
|
|
|
|
it("forwards toolChoice from simple options to payload", async () => {
|
|
const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
|
|
const model = { ...baseModel, api: "openai-completions" } as const;
|
|
const tools: Tool[] = [
|
|
{
|
|
name: "ping",
|
|
description: "Ping tool",
|
|
parameters: Type.Object({
|
|
ok: Type.Boolean(),
|
|
}),
|
|
},
|
|
];
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Call ping with ok=true",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
tools,
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
toolChoice: "required",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
} as unknown as Parameters<typeof streamSimple>[2],
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tool_choice?: string; tools?: unknown[] };
|
|
expect(params.tool_choice).toBe("required");
|
|
expect(Array.isArray(params.tools)).toBe(true);
|
|
expect(params.tools?.length ?? 0).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("omits strict when compat disables strict mode", async () => {
|
|
const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
|
|
const model = {
|
|
...baseModel,
|
|
api: "openai-completions",
|
|
compat: { supportsStrictMode: false },
|
|
} as const;
|
|
const tools: Tool[] = [
|
|
{
|
|
name: "ping",
|
|
description: "Ping tool",
|
|
parameters: Type.Object({
|
|
ok: Type.Boolean(),
|
|
}),
|
|
},
|
|
];
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Call ping with ok=true",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
tools,
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
} as unknown as Parameters<typeof streamSimple>[2],
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tools?: Array<{ function?: Record<string, unknown> }> };
|
|
const tool = params.tools?.[0]?.function;
|
|
expect(tool).toBeTruthy();
|
|
expect(tool?.strict).toBeUndefined();
|
|
expect("strict" in (tool ?? {})).toBe(false);
|
|
});
|
|
|
|
it("maps groq qwen3 reasoning levels to default reasoning_effort", async () => {
|
|
const model = getModel("groq", "qwen/qwen3-32b")!;
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Hi",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
reasoning: "medium",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { reasoning_effort?: string };
|
|
expect(params.reasoning_effort).toBe("default");
|
|
});
|
|
|
|
it("keeps normal reasoning_effort for groq models without compat mapping", async () => {
|
|
const model = getModel("groq", "openai/gpt-oss-20b")!;
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Hi",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
reasoning: "medium",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { reasoning_effort?: string };
|
|
expect(params.reasoning_effort).toBe("medium");
|
|
});
|
|
|
|
it("enables tool_stream for supported z.ai models with tools", async () => {
|
|
const model = getModel("zai", "glm-5")!;
|
|
const tools: Tool[] = [
|
|
{
|
|
name: "ping",
|
|
description: "Ping tool",
|
|
parameters: Type.Object({
|
|
ok: Type.Boolean(),
|
|
}),
|
|
},
|
|
];
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Call ping with ok=true",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
tools,
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
|
|
expect(params.tool_stream).toBe(true);
|
|
});
|
|
|
|
it("stores z.ai tool_stream support in model compat metadata", () => {
|
|
expect(getModel("zai", "glm-5")?.compat?.zaiToolStream).toBe(true);
|
|
expect(getModel("zai", "glm-4.7")?.compat?.zaiToolStream).toBe(true);
|
|
expect(getModel("zai", "glm-4.7-flash")?.compat?.zaiToolStream).toBe(true);
|
|
expect(getModel("zai", "glm-4.6v")?.compat?.zaiToolStream).toBe(true);
|
|
expect(getModel("zai", "glm-4.5-air")?.compat?.zaiToolStream).toBeUndefined();
|
|
});
|
|
|
|
it("omits tool_stream for unsupported z.ai models", async () => {
|
|
const model = getModel("zai", "glm-4.5-air")!;
|
|
const tools: Tool[] = [
|
|
{
|
|
name: "ping",
|
|
description: "Ping tool",
|
|
parameters: Type.Object({
|
|
ok: Type.Boolean(),
|
|
}),
|
|
},
|
|
];
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Call ping with ok=true",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
tools,
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
|
|
expect(params.tool_stream).toBeUndefined();
|
|
});
|
|
|
|
it("respects explicit z.ai tool_stream compat override", async () => {
|
|
const baseModel = getModel("zai", "glm-4.5-air")!;
|
|
const model = {
|
|
...baseModel,
|
|
compat: {
|
|
...baseModel.compat,
|
|
zaiToolStream: true,
|
|
},
|
|
} as const;
|
|
const tools: Tool[] = [
|
|
{
|
|
name: "ping",
|
|
description: "Ping tool",
|
|
parameters: Type.Object({
|
|
ok: Type.Boolean(),
|
|
}),
|
|
},
|
|
];
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Call ping with ok=true",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
tools,
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
|
|
expect(params.tool_stream).toBe(true);
|
|
});
|
|
|
|
it("omits tool_stream when no tools are provided", async () => {
|
|
const model = getModel("zai", "glm-5")!;
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Hi",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as { tool_stream?: boolean };
|
|
expect(params.tool_stream).toBeUndefined();
|
|
});
|
|
|
|
it("maps non-standard provider finish_reason values to stopReason error", async () => {
|
|
mockState.chunks = [
|
|
{
|
|
choices: [{ delta: { content: "partial" }, finish_reason: null }],
|
|
},
|
|
{
|
|
choices: [{ delta: {}, finish_reason: "network_error" }],
|
|
usage: {
|
|
prompt_tokens: 1,
|
|
completion_tokens: 1,
|
|
prompt_tokens_details: { cached_tokens: 0 },
|
|
completion_tokens_details: { reasoning_tokens: 0 },
|
|
},
|
|
},
|
|
];
|
|
|
|
const model = getModel("zai", "glm-5")!;
|
|
const response = await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Hi",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{ apiKey: "test" },
|
|
).result();
|
|
|
|
expect(response.stopReason).toBe("error");
|
|
expect(response.errorMessage).toBe("Provider finish_reason: network_error");
|
|
});
|
|
|
|
it("ignores null stream chunks from openai-compatible providers", async () => {
|
|
mockState.chunks = [
|
|
null,
|
|
{
|
|
id: "chatcmpl-test",
|
|
choices: [{ delta: { content: "OK" }, finish_reason: null }],
|
|
},
|
|
{
|
|
id: "chatcmpl-test",
|
|
choices: [{ delta: {}, finish_reason: "stop" }],
|
|
usage: {
|
|
prompt_tokens: 3,
|
|
completion_tokens: 1,
|
|
prompt_tokens_details: { cached_tokens: 0 },
|
|
completion_tokens_details: { reasoning_tokens: 0 },
|
|
},
|
|
},
|
|
];
|
|
|
|
const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
|
|
const model = { ...baseModel, api: "openai-completions" } as const;
|
|
const response = await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Reply with exactly OK",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{ apiKey: "test" },
|
|
).result();
|
|
|
|
expect(response.stopReason).toBe("stop");
|
|
expect(response.errorMessage).toBeUndefined();
|
|
expect(response.responseId).toBe("chatcmpl-test");
|
|
expect(response.usage.totalTokens).toBe(4);
|
|
expect(response.content).toEqual([{ type: "text", text: "OK" }]);
|
|
});
|
|
|
|
it("preserves prompt_tokens_details.cache_write_tokens from chunk usage", async () => {
|
|
mockState.chunks = [
|
|
{
|
|
id: "chatcmpl-cache-write",
|
|
choices: [{ delta: { content: "OK" }, finish_reason: null }],
|
|
},
|
|
{
|
|
id: "chatcmpl-cache-write",
|
|
choices: [{ delta: {}, finish_reason: "stop" }],
|
|
usage: {
|
|
prompt_tokens: 100,
|
|
completion_tokens: 5,
|
|
prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
|
|
completion_tokens_details: { reasoning_tokens: 0 },
|
|
},
|
|
},
|
|
];
|
|
|
|
const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
|
|
const model = { ...baseModel, api: "openai-completions" } as const;
|
|
const response = await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Reply with exactly OK",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{ apiKey: "test" },
|
|
).result();
|
|
|
|
expect(response.usage.input).toBe(50);
|
|
expect(response.usage.cacheRead).toBe(20);
|
|
expect(response.usage.cacheWrite).toBe(30);
|
|
expect(response.usage.totalTokens).toBe(105);
|
|
});
|
|
|
|
it("preserves prompt_tokens_details.cache_write_tokens from choice usage fallback", async () => {
|
|
mockState.chunks = [
|
|
{
|
|
id: "chatcmpl-cache-write-choice",
|
|
choices: [{ delta: { content: "OK" }, finish_reason: null }],
|
|
},
|
|
{
|
|
id: "chatcmpl-cache-write-choice",
|
|
choices: [
|
|
{
|
|
delta: {},
|
|
finish_reason: "stop",
|
|
usage: {
|
|
prompt_tokens: 100,
|
|
completion_tokens: 5,
|
|
prompt_tokens_details: { cached_tokens: 50, cache_write_tokens: 30 },
|
|
completion_tokens_details: { reasoning_tokens: 0 },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
];
|
|
|
|
const { compat: _compat, ...baseModel } = getModel("openai", "gpt-4o-mini")!;
|
|
const model = { ...baseModel, api: "openai-completions" } as const;
|
|
const response = await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Reply with exactly OK",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{ apiKey: "test" },
|
|
).result();
|
|
|
|
expect(response.usage.input).toBe(50);
|
|
expect(response.usage.cacheRead).toBe(20);
|
|
expect(response.usage.cacheWrite).toBe(30);
|
|
expect(response.usage.totalTokens).toBe(105);
|
|
});
|
|
|
|
it("uses OpenRouter reasoning object instead of reasoning_effort", async () => {
|
|
const model = getModel("openrouter", "deepseek/deepseek-r1")!;
|
|
let payload: unknown;
|
|
|
|
await streamSimple(
|
|
model,
|
|
{
|
|
messages: [
|
|
{
|
|
role: "user",
|
|
content: "Hi",
|
|
timestamp: Date.now(),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
apiKey: "test",
|
|
reasoning: "high",
|
|
onPayload: (params: unknown) => {
|
|
payload = params;
|
|
},
|
|
},
|
|
).result();
|
|
|
|
const params = (payload ?? mockState.lastParams) as {
|
|
reasoning?: { effort?: string };
|
|
reasoning_effort?: string;
|
|
};
|
|
expect(params.reasoning).toEqual({ effort: "high" });
|
|
expect(params.reasoning_effort).toBeUndefined();
|
|
});
|
|
});
|