wehub-resource-sync
111 lines
4.4 KiB
TypeScript
111 lines
4.4 KiB
TypeScript
/**
|
|
* LEDGER-6 (#3821-review) — the chatCore modularization (#3598) relocated ~300 lines into
|
|
* open-sse/handlers/chatCore/{idempotency,sanitization,semanticCache,memorySkillsInjection}.ts
|
|
* with no direct tests at the new seam. The extraction shipped a real `ReferenceError`
|
|
* (idempotencyKey) that no test caught. These tests pin the pure/extractable pieces:
|
|
* - sanitizeChatRequestBody (token-field normalization, empty-name stripping, tool filter)
|
|
* - checkIdempotencyCache now returns { hit, idempotencyKey } so the save site reuses the
|
|
* single derivation (no dual getIdempotencyKey call).
|
|
*/
|
|
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
|
|
import { sanitizeChatRequestBody } from "../../open-sse/handlers/chatCore/sanitization.ts";
|
|
import { checkIdempotencyCache } from "../../open-sse/handlers/chatCore/idempotency.ts";
|
|
import { FORMATS } from "../../open-sse/translator/formats.ts";
|
|
import { saveIdempotency } from "../../src/lib/idempotencyLayer.ts";
|
|
|
|
test("sanitizeChatRequestBody: Chat Completions target maps max_output_tokens → max_tokens", () => {
|
|
const out = sanitizeChatRequestBody({ max_output_tokens: 256 }, FORMATS.OPENAI, FORMATS.OPENAI);
|
|
assert.equal(out.max_tokens, 256);
|
|
assert.equal(out.max_output_tokens, undefined);
|
|
});
|
|
|
|
test("sanitizeChatRequestBody: Responses target maps max_completion_tokens → max_output_tokens", () => {
|
|
const out = sanitizeChatRequestBody(
|
|
{ max_completion_tokens: 512 },
|
|
FORMATS.OPENAI,
|
|
FORMATS.OPENAI_RESPONSES
|
|
);
|
|
assert.equal(out.max_output_tokens, 512);
|
|
assert.equal(out.max_completion_tokens, undefined);
|
|
});
|
|
|
|
test("sanitizeChatRequestBody: Responses target maps max_tokens → max_output_tokens", () => {
|
|
const out = sanitizeChatRequestBody({ max_tokens: 128 }, FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI);
|
|
assert.equal(out.max_output_tokens, 128);
|
|
assert.equal(out.max_tokens, undefined);
|
|
});
|
|
|
|
test("sanitizeChatRequestBody: strips empty message name and filters nameless tools", () => {
|
|
const out = sanitizeChatRequestBody(
|
|
{
|
|
messages: [
|
|
{ role: "user", content: "hi", name: "" },
|
|
{ role: "assistant", content: "yo", name: "keepme" },
|
|
],
|
|
tools: [
|
|
{ type: "function", function: { name: "real_tool", parameters: {} } },
|
|
{ type: "function", function: { name: "" } }, // dropped — empty name
|
|
{ type: "function", function: {} }, // dropped — no name
|
|
],
|
|
},
|
|
FORMATS.OPENAI,
|
|
FORMATS.OPENAI
|
|
);
|
|
|
|
const messages = out.messages as Array<Record<string, unknown>>;
|
|
assert.ok(!("name" in messages[0]), "empty name stripped");
|
|
assert.equal(messages[1].name, "keepme", "non-empty name kept");
|
|
|
|
const tools = out.tools as Array<Record<string, unknown>>;
|
|
assert.equal(tools.length, 1, "only the named tool survives");
|
|
assert.equal((tools[0].function as Record<string, unknown>).name, "real_tool");
|
|
});
|
|
|
|
test("checkIdempotencyCache returns { hit:null, idempotencyKey } on a miss", async () => {
|
|
const headers = new Headers({ "idempotency-key": "idem-miss-3821" });
|
|
const result = await checkIdempotencyCache({
|
|
clientRawRequest: { headers },
|
|
provider: "openai",
|
|
model: "gpt-4.1",
|
|
effectiveServiceTier: undefined,
|
|
startTime: 0,
|
|
log: undefined,
|
|
});
|
|
assert.equal(result.hit, null);
|
|
assert.equal(result.idempotencyKey, "idem-miss-3821");
|
|
});
|
|
|
|
test("checkIdempotencyCache returns a hit Response reusing the same key after a save", async () => {
|
|
const key = "idem-hit-3821";
|
|
saveIdempotency(key, { object: "chat.completion", choices: [], usage: {} }, 200);
|
|
|
|
const headers = new Headers({ "idempotency-key": key });
|
|
const result = await checkIdempotencyCache({
|
|
clientRawRequest: { headers },
|
|
provider: "openai",
|
|
model: "gpt-4.1",
|
|
effectiveServiceTier: undefined,
|
|
startTime: 0,
|
|
log: undefined,
|
|
});
|
|
|
|
assert.equal(result.idempotencyKey, key, "the resolved key is returned for the save site to reuse");
|
|
assert.ok(result.hit, "a cached entry produces a hit");
|
|
assert.equal(result.hit!.response.headers.get("X-OmniRoute-Idempotent"), "true");
|
|
});
|
|
|
|
test("checkIdempotencyCache resolves a null key when no idempotency headers are present", async () => {
|
|
const result = await checkIdempotencyCache({
|
|
clientRawRequest: { headers: new Headers() },
|
|
provider: "openai",
|
|
model: "gpt-4.1",
|
|
effectiveServiceTier: undefined,
|
|
startTime: 0,
|
|
log: undefined,
|
|
});
|
|
assert.equal(result.hit, null);
|
|
assert.equal(result.idempotencyKey, null);
|
|
});
|