wehub-resource-sync
890 lines
30 KiB
TypeScript
890 lines
30 KiB
TypeScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
const { HuggingChatExecutor } = await import("../../open-sse/executors/huggingchat.ts");
|
|
const { PoeWebExecutor } = await import("../../open-sse/executors/poe-web.ts");
|
|
const { VeniceWebExecutor } = await import("../../open-sse/executors/venice-web.ts");
|
|
const { V0VercelWebExecutor } = await import("../../open-sse/executors/v0-vercel-web.ts");
|
|
const { KimiWebExecutor } = await import("../../open-sse/executors/kimi-web.ts");
|
|
const { DoubaoWebExecutor } = await import("../../open-sse/executors/doubao-web.ts");
|
|
const { QwenWebExecutor } = await import("../../open-sse/executors/qwen-web.ts");
|
|
const { getExecutor, hasSpecializedExecutor } = await import("../../open-sse/executors/index.ts");
|
|
|
|
// ── Helpers ──────────────────────────────────────────────────────────────────
|
|
|
|
type MockFetchInput = Parameters<typeof fetch>[0];
|
|
type MockFetchInit = Parameters<typeof fetch>[1];
|
|
|
|
function mockSSEStream(chunks: string[]) {
|
|
const encoder = new TextEncoder();
|
|
return new ReadableStream({
|
|
start(controller) {
|
|
for (const chunk of chunks) {
|
|
controller.enqueue(encoder.encode(chunk));
|
|
}
|
|
controller.enqueue(encoder.encode("data: [DONE]\n\n"));
|
|
controller.close();
|
|
},
|
|
});
|
|
}
|
|
|
|
function mockJSONLStream(lines: string[]) {
|
|
const encoder = new TextEncoder();
|
|
return new ReadableStream({
|
|
start(controller) {
|
|
for (const line of lines) {
|
|
controller.enqueue(encoder.encode(line + "\n"));
|
|
}
|
|
controller.close();
|
|
},
|
|
});
|
|
}
|
|
|
|
const HUGGINGCHAT_ROOT_ID = "00000000-0000-4000-8000-000000000001";
|
|
|
|
function mockHuggingChatConversationDetail(rootId = HUGGINGCHAT_ROOT_ID) {
|
|
return new Response(
|
|
JSON.stringify({
|
|
json: {
|
|
rootMessageId: rootId,
|
|
messages: [{ id: rootId, from: "system" }],
|
|
},
|
|
}),
|
|
{
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
}
|
|
);
|
|
}
|
|
|
|
function mockFetchCapture(status = 200, responseBody?: ReadableStream | string) {
|
|
const original = globalThis.fetch;
|
|
let capturedUrl: string | null = null;
|
|
let capturedHeaders: Record<string, string> = {};
|
|
let capturedBody: string | null = null;
|
|
|
|
const body =
|
|
typeof responseBody === "string"
|
|
? new ReadableStream({
|
|
start(controller) {
|
|
controller.enqueue(new TextEncoder().encode(responseBody));
|
|
controller.close();
|
|
},
|
|
})
|
|
: responseBody;
|
|
|
|
globalThis.fetch = async (url: MockFetchInput, opts?: MockFetchInit) => {
|
|
capturedUrl = String(url);
|
|
capturedHeaders = opts?.headers || {};
|
|
capturedBody = opts?.body || null;
|
|
return new Response(body || "", {
|
|
status,
|
|
headers: { "Content-Type": "text/event-stream; charset=utf-8" },
|
|
});
|
|
};
|
|
|
|
return {
|
|
restore: () => {
|
|
globalThis.fetch = original;
|
|
},
|
|
get url() {
|
|
return capturedUrl;
|
|
},
|
|
get headers() {
|
|
return capturedHeaders;
|
|
},
|
|
get body() {
|
|
return capturedBody;
|
|
},
|
|
};
|
|
}
|
|
|
|
const noopExecuteInput = {
|
|
model: "test-model",
|
|
body: { messages: [{ role: "user", content: "hello" }] },
|
|
stream: true,
|
|
credentials: { apiKey: "test-cookie" },
|
|
signal: null,
|
|
};
|
|
|
|
// ── Registration Tests ───────────────────────────────────────────────────────
|
|
|
|
test("HuggingChat executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("huggingchat"));
|
|
assert.ok(hasSpecializedExecutor("hc"));
|
|
const executor = getExecutor("huggingchat");
|
|
assert.ok(executor instanceof HuggingChatExecutor);
|
|
});
|
|
|
|
test("Poe Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("poe-web"));
|
|
assert.ok(hasSpecializedExecutor("poe"));
|
|
const executor = getExecutor("poe-web");
|
|
assert.ok(executor instanceof PoeWebExecutor);
|
|
});
|
|
|
|
test("Venice Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("venice-web"));
|
|
assert.ok(hasSpecializedExecutor("ven"));
|
|
const executor = getExecutor("venice-web");
|
|
assert.ok(executor instanceof VeniceWebExecutor);
|
|
});
|
|
|
|
test("v0 Vercel Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("v0-vercel-web"));
|
|
assert.ok(hasSpecializedExecutor("v0"));
|
|
const executor = getExecutor("v0-vercel-web");
|
|
assert.ok(executor instanceof V0VercelWebExecutor);
|
|
});
|
|
|
|
test("Kimi Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("kimi-web"));
|
|
// #4699: the `kimi` API-key provider must NOT be routed through KimiWebExecutor
|
|
// (Bug 2) — it correctly falls through to DefaultExecutor. Only the explicit
|
|
// kimi-web alias keeps the specialized web executor.
|
|
assert.equal(hasSpecializedExecutor("kimi"), false);
|
|
const executor = getExecutor("kimi-web");
|
|
assert.ok(executor instanceof KimiWebExecutor);
|
|
});
|
|
|
|
test("Doubao Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("doubao-web"));
|
|
assert.ok(hasSpecializedExecutor("db"));
|
|
const executor = getExecutor("doubao-web");
|
|
assert.ok(executor instanceof DoubaoWebExecutor);
|
|
});
|
|
|
|
// ── Constructor Tests ────────────────────────────────────────────────────────
|
|
|
|
test("HuggingChat sets correct provider", () => {
|
|
const executor = new HuggingChatExecutor();
|
|
assert.equal(executor.getProvider(), "huggingchat");
|
|
});
|
|
|
|
test("Poe Web sets correct provider", () => {
|
|
const executor = new PoeWebExecutor();
|
|
assert.equal(executor.getProvider(), "poe-web");
|
|
});
|
|
|
|
test("Venice Web sets correct provider", () => {
|
|
const executor = new VeniceWebExecutor();
|
|
assert.equal(executor.getProvider(), "venice-web");
|
|
});
|
|
|
|
test("v0 Vercel Web sets correct provider", () => {
|
|
const executor = new V0VercelWebExecutor();
|
|
assert.equal(executor.getProvider(), "v0-vercel-web");
|
|
});
|
|
|
|
test("Kimi Web sets correct provider", () => {
|
|
const executor = new KimiWebExecutor();
|
|
assert.equal(executor.getProvider(), "kimi-web");
|
|
});
|
|
|
|
test("Doubao Web sets correct provider", () => {
|
|
const executor = new DoubaoWebExecutor();
|
|
assert.equal(executor.getProvider(), "doubao-web");
|
|
});
|
|
|
|
// ── Registration Tests (Qwen Web) ────────────────────────────────────────────
|
|
|
|
test("Qwen Web executor is registered", () => {
|
|
assert.ok(hasSpecializedExecutor("qwen-web"));
|
|
assert.ok(hasSpecializedExecutor("qw"));
|
|
const executor = getExecutor("qwen-web");
|
|
assert.ok(executor instanceof QwenWebExecutor);
|
|
});
|
|
|
|
// ── Constructor Tests (Qwen Web) ─────────────────────────────────────────────
|
|
|
|
test("Qwen Web sets correct provider", () => {
|
|
const executor = new QwenWebExecutor();
|
|
assert.equal(executor.getProvider(), "qwen-web");
|
|
});
|
|
|
|
// ── HuggingChat Execution Tests ──────────────────────────────────────────────
|
|
|
|
test("HuggingChat: streaming returns SSE chunks", async () => {
|
|
const jsonlData = [
|
|
JSON.stringify({ type: "stream", token: "Hello " }),
|
|
JSON.stringify({ type: "stream", token: "world" }),
|
|
JSON.stringify({ type: "finalAnswer", text: "Hello world" }),
|
|
];
|
|
|
|
const original = globalThis.fetch;
|
|
let callCount = 0;
|
|
globalThis.fetch = async (url: MockFetchInput, opts?: MockFetchInit) => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
// First call: create conversation
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
|
|
return new Response(mockJSONLStream(jsonlData), {
|
|
status: 200,
|
|
headers: { "Content-Type": "text/plain; charset=utf-8" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "meta-llama/Llama-3.3-70B-Instruct",
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 200);
|
|
assert.ok(result.url.includes("huggingface.co"));
|
|
const text = await result.response.text();
|
|
assert.ok(text.includes("data:"));
|
|
assert.ok(text.includes("[DONE]"));
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: sends current web data payload with the root parent id", async () => {
|
|
const original = globalThis.fetch;
|
|
let sentData: Record<string, unknown> | null = null;
|
|
let callCount = 0;
|
|
globalThis.fetch = async (_url: MockFetchInput, opts?: MockFetchInit) => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
|
|
const form = opts.body as FormData;
|
|
sentData = JSON.parse(String(form.get("data")));
|
|
return new Response(
|
|
mockJSONLStream([JSON.stringify({ type: "finalAnswer", text: "Hello world" })]),
|
|
{
|
|
status: 200,
|
|
headers: { "Content-Type": "text/plain; charset=utf-8" },
|
|
}
|
|
);
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "meta-llama/Llama-3.3-70B-Instruct",
|
|
});
|
|
await result.response.text();
|
|
|
|
assert.equal(sentData?.inputs, "hello");
|
|
assert.equal(sentData?.id, HUGGINGCHAT_ROOT_ID);
|
|
assert.equal(sentData?.is_retry, false);
|
|
assert.equal(sentData?.is_continue, false);
|
|
assert.equal(typeof sentData?.generationId, "string");
|
|
assert.deepEqual(sentData?.selectedMcpServerNames, []);
|
|
assert.deepEqual(sentData?.selectedMcpServers, []);
|
|
assert.equal(typeof sentData?.timezone, "string");
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: carries create response Set-Cookie into message send", async () => {
|
|
const original = globalThis.fetch;
|
|
let sendCookie = "";
|
|
let callCount = 0;
|
|
globalThis.fetch = async (_url: MockFetchInput, opts?: MockFetchInit) => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: [
|
|
["Content-Type", "application/json"],
|
|
["Set-Cookie", "hf-chat=fresh-session; Path=/; HttpOnly"],
|
|
["Set-Cookie", "aws-waf-token=fresh-waf; Path=/; HttpOnly"],
|
|
],
|
|
});
|
|
}
|
|
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
|
|
sendCookie = opts.headers.Cookie;
|
|
return new Response(
|
|
mockJSONLStream([JSON.stringify({ type: "finalAnswer", text: "Hello world" })]),
|
|
{
|
|
status: 200,
|
|
headers: { "Content-Type": "text/plain; charset=utf-8" },
|
|
}
|
|
);
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "hf-chat=stale-session; token=login-token" },
|
|
model: "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT",
|
|
});
|
|
await result.response.text();
|
|
|
|
assert.match(sendCookie, /(?:^|;\s*)hf-chat=fresh-session(?:;|$)/);
|
|
assert.match(sendCookie, /(?:^|;\s*)aws-waf-token=fresh-waf(?:;|$)/);
|
|
assert.match(sendCookie, /(?:^|;\s*)token=login-token(?:;|$)/);
|
|
assert.doesNotMatch(sendCookie, /hf-chat=stale-session/);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: default model is a current concrete catalog model", async () => {
|
|
const original = globalThis.fetch;
|
|
let createModel: unknown = null;
|
|
let callCount = 0;
|
|
globalThis.fetch = async (_url: MockFetchInput, opts?: MockFetchInit) => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
createModel = JSON.parse(String(opts.body)).model;
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
|
|
return new Response(
|
|
mockJSONLStream([JSON.stringify({ type: "finalAnswer", text: "Hello world" })]),
|
|
{
|
|
status: 200,
|
|
headers: { "Content-Type": "text/plain; charset=utf-8" },
|
|
}
|
|
);
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "",
|
|
});
|
|
await result.response.text();
|
|
|
|
assert.equal(createModel, "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT");
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: message send errors include sanitized upstream details", async () => {
|
|
const original = globalThis.fetch;
|
|
let callCount = 0;
|
|
globalThis.fetch = async () => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
return new Response(JSON.stringify({ message: "invalid parent message id", status: "error" }), {
|
|
status: 400,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
stream: false,
|
|
});
|
|
assert.equal(result.response.status, 400);
|
|
const parsed = JSON.parse(await result.response.text());
|
|
assert.match(parsed.error.message, /invalid parent message id/i);
|
|
assert.equal(parsed.upstream_details.message, "invalid parent message id");
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: message send errors preserve the attempted send payload", async () => {
|
|
const original = globalThis.fetch;
|
|
let callCount = 0;
|
|
globalThis.fetch = async () => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
return new Response(JSON.stringify({ message: "An error occurred" }), {
|
|
status: 500,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT",
|
|
stream: false,
|
|
});
|
|
|
|
assert.equal(result.response.status, 500);
|
|
assert.equal(result.transformedBody.inputs, "hello");
|
|
assert.equal(result.transformedBody.id, HUGGINGCHAT_ROOT_ID);
|
|
assert.equal(result.transformedBody.is_retry, false);
|
|
assert.equal(result.transformedBody.is_continue, false);
|
|
assert.equal(typeof result.transformedBody.generationId, "string");
|
|
assert.deepEqual(result.transformedBody.selectedMcpServerNames, []);
|
|
assert.deepEqual(result.transformedBody.selectedMcpServers, []);
|
|
assert.equal(typeof result.transformedBody.timezone, "string");
|
|
assert.ok(!JSON.stringify(result.transformedBody).includes("test-cookie"));
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: non-streaming returns JSON completion", async () => {
|
|
const jsonlData = [
|
|
JSON.stringify({ type: "stream", token: "Hello " }),
|
|
JSON.stringify({ type: "stream", token: "world" }),
|
|
JSON.stringify({ type: "finalAnswer", text: "Hello world" }),
|
|
];
|
|
|
|
const original = globalThis.fetch;
|
|
let callCount = 0;
|
|
globalThis.fetch = async (url: MockFetchInput, opts?: MockFetchInit) => {
|
|
callCount++;
|
|
if (callCount === 1) {
|
|
return new Response(JSON.stringify({ conversationId: "test-conv-123" }), {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
}
|
|
if (callCount === 2) {
|
|
return mockHuggingChatConversationDetail();
|
|
}
|
|
return new Response(mockJSONLStream(jsonlData), {
|
|
status: 200,
|
|
headers: { "Content-Type": "text/plain; charset=utf-8" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
stream: false,
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
const text = await result.response.text();
|
|
const parsed = JSON.parse(text);
|
|
assert.equal(parsed.object, "chat.completion");
|
|
assert.ok(parsed.choices[0].message.content);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: error response returns error result", async () => {
|
|
const original = globalThis.fetch;
|
|
globalThis.fetch = async () => {
|
|
return new Response("Unauthorized", {
|
|
status: 401,
|
|
headers: { "Content-Type": "text/plain" },
|
|
});
|
|
};
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "bad-cookie" },
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 401);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: encrypted credential blob fails before upstream fetch", async () => {
|
|
const original = globalThis.fetch;
|
|
let fetchCalled = false;
|
|
globalThis.fetch = async () => {
|
|
fetchCalled = true;
|
|
return new Response("should not fetch", { status: 500 });
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "enc:v1:fake-iv:fake-ciphertext:fake-tag" },
|
|
});
|
|
const body = await result.response.json();
|
|
|
|
assert.equal(fetchCalled, false);
|
|
assert.equal(result.response.status, 401);
|
|
assert.match(body.error.message, /STORAGE_ENCRYPTION_KEY/);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("HuggingChat: fetch failure returns 502", async () => {
|
|
const original = globalThis.fetch;
|
|
globalThis.fetch = async () => {
|
|
throw new Error("Network error");
|
|
};
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute(noopExecuteInput);
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 502);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
// ── Poe Web Execution Tests ──────────────────────────────────────────────────
|
|
|
|
test("Poe Web: non-streaming returns JSON completion", async () => {
|
|
const mockResponse = JSON.stringify({
|
|
data: { chatWithBot: { text: "Hello from Poe" } },
|
|
});
|
|
const restore = mockFetchCapture(200, mockResponse);
|
|
try {
|
|
const executor = new PoeWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
stream: false,
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
const text = await result.response.text();
|
|
const parsed = JSON.parse(text);
|
|
assert.equal(parsed.object, "chat.completion");
|
|
assert.ok(parsed.choices[0].message.content);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("Poe Web: sends p-b cookie in header", async () => {
|
|
const mockResponse = JSON.stringify({
|
|
data: { chatWithBot: { text: "ok" } },
|
|
});
|
|
const restore = mockFetchCapture(200, mockResponse);
|
|
try {
|
|
const executor = new PoeWebExecutor();
|
|
await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "p-b=abc123" },
|
|
stream: false,
|
|
});
|
|
assert.ok(restore.headers.Cookie?.includes("p-b=abc123"));
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
// ── Venice Web Execution Tests ───────────────────────────────────────────────
|
|
|
|
test("Venice Web: streaming passes through SSE", async () => {
|
|
const sseData = ['data: {"choices":[{"delta":{"content":"Hello"}}]}'];
|
|
const restore = mockFetchCapture(200, mockSSEStream(sseData));
|
|
try {
|
|
const executor = new VeniceWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "venice-default",
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.ok(result.url.includes("venice.ai"));
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("Venice Web: error response returns error result", async () => {
|
|
const restore = mockFetchCapture(500, "Internal Server Error");
|
|
try {
|
|
const executor = new VeniceWebExecutor();
|
|
const result = await executor.execute(noopExecuteInput);
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 500);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
// ── v0 Vercel Web Execution Tests ────────────────────────────────────────────
|
|
|
|
test("v0 Vercel Web: streaming passes through SSE", async () => {
|
|
const sseData = ['data: {"choices":[{"delta":{"content":"function hello() {}"}}]}'];
|
|
const restore = mockFetchCapture(200, mockSSEStream(sseData));
|
|
try {
|
|
const executor = new V0VercelWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "v0-default",
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.ok(result.url.includes("v0.dev"));
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("v0 Vercel Web: error response returns error result", async () => {
|
|
const restore = mockFetchCapture(429, "Rate limited");
|
|
try {
|
|
const executor = new V0VercelWebExecutor();
|
|
const result = await executor.execute(noopExecuteInput);
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 429);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
// ── Kimi Web Execution Tests ─────────────────────────────────────────────────
|
|
|
|
test("Kimi Web: targets www.kimi.com (international)", async () => {
|
|
// The new executor talks to the Connect-RPC streaming endpoint on the
|
|
// international domain. A bare empty credential is rejected before the
|
|
// fetch fires, so we feed a fake JWT and let the mock absorb the request.
|
|
const restore = mockFetchCapture(200);
|
|
try {
|
|
const executor = new KimiWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "k2d6",
|
|
credentials: { apiKey: "kimi-auth=eyJ.eyJzdWI.signature" },
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
// Parse the URL and assert on the exact hostname rather than a substring
|
|
// match — `includes("www.kimi.com")` would also accept a hostile host like
|
|
// `www.kimi.com.evil.net` or `evil.net/?x=www.kimi.com` (CodeQL
|
|
// js/incomplete-url-substring-sanitization).
|
|
const host = new URL(result.url).hostname;
|
|
assert.equal(host, "www.kimi.com", `got ${result.url}`);
|
|
assert.notEqual(host, "www.moonshot.cn", `got ${result.url}`);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("Kimi Web: missing JWT returns a 400 before fetching", async () => {
|
|
const executor = new KimiWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "k2d6",
|
|
credentials: { apiKey: "" },
|
|
});
|
|
assert.equal(result.response.status, 400);
|
|
});
|
|
|
|
test("Kimi Web: error response returns error result", async () => {
|
|
const restore = mockFetchCapture(401, "Unauthorized");
|
|
try {
|
|
const executor = new KimiWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "k2d6",
|
|
credentials: { apiKey: "kimi-auth=eyJ.eyJzdWI.signature" },
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 401);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
// ── Doubao Web Execution Tests ───────────────────────────────────────────────
|
|
|
|
test("Doubao Web: streaming converts Dola SSE chunks", async () => {
|
|
const sseData = [
|
|
'event: STREAM_MSG_NOTIFY\ndata: {"content":{"content_block":[{"content":{"text_block":{"text":"hello"}}}]}}\n\n',
|
|
'event: STREAM_CHUNK\ndata: {"message_id":"mid","patch_op":[{"patch_value":{"content_block":[{"content":{"text_block":{"text":" world"}}}]}}]}\n\n',
|
|
];
|
|
const restore = mockFetchCapture(200, mockSSEStream(sseData));
|
|
try {
|
|
const executor = new DoubaoWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "dola-speed",
|
|
credentials: { apiKey: "sessionid=sid; ttwid=tt; s_v_web_id=verify_abc" },
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(new URL(result.url).hostname, "www.dola.com");
|
|
assert.equal(result.transformedBody.option.need_create_conversation, true);
|
|
const streamed = await result.response.text();
|
|
assert.match(streamed, /hello/);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("Doubao Web: Dola Pro returns final answer after reasoning boundary", async () => {
|
|
const sseData = [
|
|
'event: STREAM_CHUNK\ndata: {"message_id":"mid","patch_op":[{"patch_object":1,"patch_type":1,"patch_value":{"content_block":[{"block_type":10000,"content":{"text_block":{"text":"The user asked for 1+1. "}},"is_finish":false}]}}]}\n\n',
|
|
'event: STREAM_CHUNK\ndata: {"message_id":"mid","patch_op":[{"patch_object":1,"patch_type":1,"patch_value":{"content_block":[{"block_type":10000,"content":{"text_block":{"text":"That is straightforward: 2."}},"is_finish":false}]}}]}\n\n',
|
|
'event: STREAM_CHUNK\ndata: {"message_id":"mid","patch_op":[{"patch_object":1,"patch_type":1,"patch_value":{"content_block":[{"block_type":10040,"content":{"text_block":{}},"is_finish":true}]}}]}\n\n',
|
|
'event: STREAM_CHUNK\ndata: {"message_id":"mid","patch_op":[{"patch_object":1,"patch_type":1,"patch_value":{"content_block":[{"block_type":10000,"content":{"text_block":{"text":"2"}},"is_finish":false}]}}]}\n\n',
|
|
'event: SSE_REPLY_END\ndata: {"end_type":1}\n\n',
|
|
];
|
|
const restore = mockFetchCapture(200, mockSSEStream(sseData));
|
|
try {
|
|
const executor = new DoubaoWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
model: "dola-pro",
|
|
stream: false,
|
|
credentials: { apiKey: "sessionid=sid; ttwid=tt; s_v_web_id=verify_abc" },
|
|
});
|
|
const body = await result.response.json();
|
|
|
|
assert.equal(result.transformedBody.option.need_deep_think, 3);
|
|
assert.equal(result.transformedBody.ext.use_deep_think, "3");
|
|
assert.equal(body.choices[0].message.content, "2");
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
test("Doubao Web: error response returns error result", async () => {
|
|
const restore = mockFetchCapture(502, "Bad Gateway");
|
|
try {
|
|
const executor = new DoubaoWebExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "sessionid=sid; ttwid=tt; s_v_web_id=verify_abc" },
|
|
});
|
|
assert.ok(result.response instanceof Response);
|
|
assert.equal(result.response.status, 502);
|
|
} finally {
|
|
restore.restore();
|
|
}
|
|
});
|
|
|
|
// ── Cookie Normalization Tests ───────────────────────────────────────────────
|
|
|
|
test("All executors handle Cookie: prefix", async () => {
|
|
const executors = [
|
|
new HuggingChatExecutor(),
|
|
new PoeWebExecutor(),
|
|
new VeniceWebExecutor(),
|
|
new V0VercelWebExecutor(),
|
|
new KimiWebExecutor(),
|
|
new DoubaoWebExecutor(),
|
|
];
|
|
|
|
const original = globalThis.fetch;
|
|
let lastHeaders: Record<string, string> = {};
|
|
globalThis.fetch = async (_url: MockFetchInput, opts?: MockFetchInit) => {
|
|
lastHeaders = opts?.headers || {};
|
|
// Poe expects JSON response with chatWithBot
|
|
const body = JSON.stringify({ data: { chatWithBot: { text: "ok" } } });
|
|
return new Response(body, {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
for (const executor of executors) {
|
|
await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "Cookie: sessionid=test; ttwid=tt; s_v_web_id=verify_test" },
|
|
stream: false,
|
|
});
|
|
// Cookie should be normalized (may or may not have prefix depending on executor)
|
|
assert.ok(lastHeaders.Cookie || lastHeaders.Authorization || lastHeaders["Content-Type"]);
|
|
}
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
test("All executors handle bare cookie value", async () => {
|
|
const executors = [
|
|
new HuggingChatExecutor(),
|
|
new PoeWebExecutor(),
|
|
new VeniceWebExecutor(),
|
|
new V0VercelWebExecutor(),
|
|
new KimiWebExecutor(),
|
|
new DoubaoWebExecutor(),
|
|
];
|
|
|
|
const original = globalThis.fetch;
|
|
let lastHeaders: Record<string, string> = {};
|
|
globalThis.fetch = async (_url: MockFetchInput, opts?: MockFetchInit) => {
|
|
lastHeaders = opts?.headers || {};
|
|
// Poe expects JSON response with chatWithBot
|
|
const body = JSON.stringify({ data: { chatWithBot: { text: "ok" } } });
|
|
return new Response(body, {
|
|
status: 200,
|
|
headers: { "Content-Type": "application/json" },
|
|
});
|
|
};
|
|
|
|
try {
|
|
for (const executor of executors) {
|
|
await executor.execute({
|
|
...noopExecuteInput,
|
|
credentials: { apiKey: "bare-cookie-value" },
|
|
stream: false,
|
|
});
|
|
assert.ok(lastHeaders["Content-Type"]);
|
|
}
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|
|
|
|
// ── Abort Signal Tests ───────────────────────────────────────────────────────
|
|
|
|
test("HuggingChat: respects abort signal", async () => {
|
|
const controller = new AbortController();
|
|
controller.abort();
|
|
|
|
const original = globalThis.fetch;
|
|
let fetchCalled = false;
|
|
globalThis.fetch = async (_url: MockFetchInput, _opts?: MockFetchInit) => {
|
|
fetchCalled = true;
|
|
return new Response("ok", { status: 200 });
|
|
};
|
|
|
|
try {
|
|
const executor = new HuggingChatExecutor();
|
|
const result = await executor.execute({
|
|
...noopExecuteInput,
|
|
signal: controller.signal,
|
|
});
|
|
// Should still complete (fetch may or may not be called depending on implementation)
|
|
assert.ok(result.response instanceof Response);
|
|
} finally {
|
|
globalThis.fetch = original;
|
|
}
|
|
});
|