jesse-ux
dcfc2f15af
Replace append_consultation_question so the 200,000 quota sums only user-visible text, and add a 1,000,000-byte whole-JSON physical cap. Both still return session_full. Advisory lock, request_id idempotency, and the 200-message cap are unchanged.
289 lines
12 KiB
TypeScript
289 lines
12 KiB
TypeScript
import assert from "node:assert/strict";
|
||
import { existsSync, readdirSync, readFileSync } from "node:fs";
|
||
import { fileURLToPath } from "node:url";
|
||
import test from "node:test";
|
||
|
||
import { natalConsultationThinkingPlan } from "../src/lib/consultation-thinking-plan.ts";
|
||
|
||
const migrationsDir = new URL("../supabase/migrations/", import.meta.url);
|
||
const originalSql = readFileSync(
|
||
new URL("../supabase/migrations/20260901010000_append_consultation_question.sql", import.meta.url),
|
||
"utf8",
|
||
);
|
||
const sql = readFileSync(
|
||
new URL("../supabase/migrations/20260916010000_consultation_session_capacity.sql", import.meta.url),
|
||
"utf8",
|
||
);
|
||
const itemRoute = readFileSync(
|
||
new URL("../src/app/api/sessions/[id]/route.ts", import.meta.url),
|
||
"utf8",
|
||
);
|
||
const consultRoute = readFileSync(
|
||
new URL("../src/app/api/consult/route.ts", import.meta.url),
|
||
"utf8",
|
||
);
|
||
|
||
const SESSION_SELECT =
|
||
"id,title,theme,model_id,messages,session_type,rectification_case_id,chart_profile_id,chart_profile_name,chart_profile_role,updated_at,pinned,archived_at";
|
||
|
||
function functionBody(source: string): string {
|
||
const match = source.match(/as \$\$\r?\n([\s\S]*?)\r?\n\$\$;/);
|
||
assert.ok(match?.[1], "function body must be present");
|
||
return match[1];
|
||
}
|
||
|
||
function withoutLineComments(source: string): string {
|
||
return source.replace(/--[^\n]*/g, "");
|
||
}
|
||
|
||
function utf8Bytes(value: string): number {
|
||
return Buffer.byteLength(value, "utf8");
|
||
}
|
||
|
||
function typicalReceipts(domains: readonly string[]) {
|
||
const workflowReceipt = {
|
||
route: "multi-domain",
|
||
status: "ready",
|
||
preciseTiming: "allowed",
|
||
missingLayers: [] as string[],
|
||
domains,
|
||
};
|
||
const agentExecutionReceipt = {
|
||
runId: "run-typical",
|
||
runtime: "mastra-agentic" as const,
|
||
skill: {
|
||
name: "jyotish-vedic-astrology" as const,
|
||
loaded: true,
|
||
version: "1.0.0",
|
||
referenceReads: 2,
|
||
methodologySections: 4,
|
||
},
|
||
steps: [
|
||
{ sequence: 1, kind: "skill" as const, name: "jyotish-vedic-astrology", status: "completed" as const, durationMs: 120 },
|
||
{ sequence: 2, kind: "tool" as const, name: "run-jyotish-consultation", status: "completed" as const, durationMs: 1800 },
|
||
],
|
||
stepBudget: { planned: 8, used: 2, remaining: 6, truncated: false },
|
||
workflow: workflowReceipt,
|
||
techniqueTruth: "verified",
|
||
techniqueAuditTable: [
|
||
{ technique: "VedAstro Cloud State", status: "blocked" as const, note: "未经核验的官方云证据，置信度封顶" },
|
||
{ technique: "Functional Benefic/Malefic", status: "executed" as const, note: "功能属性与自然属性冲突时降置信" },
|
||
{ technique: "Formal Vargas D1–D60", status: "executed" as const, note: "20/20 传统命名分盘" },
|
||
{ technique: "Vimshottari sub-periods", status: "executed" as const, note: "本轮已纳入证据计划" },
|
||
{ technique: "Narayana Dasha", status: "executed" as const, note: "本轮无独立当前读数" },
|
||
{ technique: "Yogas", status: "executed" as const, note: "成盘与落空均列出" },
|
||
{ technique: "Ashtakavarga", status: "executed" as const, note: "本轮已纳入证据计划" },
|
||
{ technique: "Shadbala components", status: "executed" as const, note: "本轮已纳入证据计划" },
|
||
{ technique: "MEVG / Global Web Evidence", status: "blocked" as const, note: "本轮未闭合" },
|
||
{ technique: "Real Case Calibration", status: "blocked" as const, note: "本轮未闭合" },
|
||
{ technique: "Timing Precision Gate", status: "executed" as const, note: "按声明精度封顶" },
|
||
{ technique: "Prashna chart", status: "not_applicable" as const, note: "本轮为本命咨询" },
|
||
],
|
||
};
|
||
return {
|
||
techniqueTruth: "verified",
|
||
workflowReceipt,
|
||
agentExecutionReceipt,
|
||
};
|
||
}
|
||
|
||
function thinkingPlan(domains: readonly ("career" | "wealth" | "marriage")[]) {
|
||
return natalConsultationThinkingPlan({
|
||
domains,
|
||
requiredBlocks: [
|
||
"raw_structure",
|
||
"raman_six_step",
|
||
"yoga_table",
|
||
"timing",
|
||
"synthesis",
|
||
"technique_audit_table",
|
||
"modern_wrap",
|
||
],
|
||
mustUseLayers: ["D1", "run-jyotish-consultation", "D10", "skill_read"],
|
||
});
|
||
}
|
||
|
||
function assistantMessage(_index: number, domains: readonly ("career" | "wealth" | "marriage")[]) {
|
||
const receipts = typicalReceipts(domains);
|
||
return {
|
||
role: "assistant" as const,
|
||
text: "正".repeat(4000),
|
||
thinkingText: "思".repeat(4000),
|
||
thinkingSections: thinkingPlan(domains),
|
||
...receipts,
|
||
};
|
||
}
|
||
|
||
function userMessage(index: number) {
|
||
return {
|
||
role: "user" as const,
|
||
text: `第${String(index + 1).padStart(2, "0")}问`.padEnd(100, "问"),
|
||
requestId: `capacity-req-${index + 1}`,
|
||
};
|
||
}
|
||
|
||
function sessionDetailPayload(rounds: number, domains: readonly ("career" | "wealth" | "marriage")[]) {
|
||
const messages = Array.from({ length: rounds }, (_, index) => [
|
||
userMessage(index),
|
||
assistantMessage(index, domains),
|
||
]).flat();
|
||
return {
|
||
session: {
|
||
id: "00000000-0000-4000-8000-000000000001",
|
||
title: "事业方向",
|
||
theme: "career",
|
||
model_id: "test-model",
|
||
messages,
|
||
session_type: "consultation",
|
||
rectification_case_id: null,
|
||
chart_profile_id: null,
|
||
chart_profile_name: null,
|
||
chart_profile_role: null,
|
||
updated_at: "2026-09-15T00:00:00.000Z",
|
||
pinned: false,
|
||
archived_at: null,
|
||
},
|
||
};
|
||
}
|
||
|
||
function countedText(messages: readonly { text?: string }[]): number {
|
||
return messages.reduce((sum, message) => sum + (message.text ?? "").length, 0);
|
||
}
|
||
|
||
function oldCountedChars(messages: readonly Record<string, unknown>[]): number {
|
||
return messages.reduce((sum, message) => {
|
||
const text = typeof message.text === "string" ? message.text.length : 0;
|
||
const thinking = typeof message.thinkingText === "string" ? message.thinkingText.length : 0;
|
||
const sections = "thinkingSections" in message
|
||
? JSON.stringify(message.thinkingSections).length
|
||
: 0;
|
||
return sum + text + thinking + sections;
|
||
}, 0);
|
||
}
|
||
|
||
test("the capacity migration is the latest replace of append_consultation_question", () => {
|
||
const names = readdirSync(fileURLToPath(migrationsDir))
|
||
.filter((name) => name.endsWith(".sql"))
|
||
.sort();
|
||
const replaces = names.filter((name) =>
|
||
name.includes("append_consultation_question") || name.includes("consultation_session_capacity"),
|
||
);
|
||
assert.deepEqual(replaces.at(-1), "20260916010000_consultation_session_capacity.sql");
|
||
assert.equal(
|
||
existsSync(fileURLToPath(new URL("../db/migrations/20260916010000_consultation_session_capacity.sql", import.meta.url))),
|
||
false,
|
||
"business migration must not be copied into frontend/db/migrations (BUG-127/BUG-144)",
|
||
);
|
||
});
|
||
|
||
test("CREATE OR REPLACE keeps the BUG-464 signature, lock, idempotency, and error codes", () => {
|
||
assert.match(
|
||
sql,
|
||
/create or replace function public\.append_consultation_question\(\s*p_user_id uuid,\s*p_request_id text,\s*p_session_id uuid,\s*p_question_message jsonb\s*\)/,
|
||
);
|
||
assert.match(sql, /returns table\(success boolean, error_code text\)/);
|
||
const body = functionBody(sql);
|
||
assert.match(body, /pg_advisory_xact_lock/);
|
||
assert.match(body, /elem->>'requestId' = v_request_id/);
|
||
assert.match(body, /return query select true, null::text;/);
|
||
assert.match(body, /'session_missing'::text/);
|
||
assert.match(body, /'session_full'::text/);
|
||
assert.match(body, /'invalid_request'::text/);
|
||
assert.match(body, /'invalid_question_message'::text/);
|
||
assert.match(body, /char_length\(v_text\) > 16000/);
|
||
assert.match(body, /v_count >= 200/);
|
||
assert.match(body, /\(v_chars \+ v_new_chars\) > 200000/);
|
||
assert.match(
|
||
sql,
|
||
/revoke all on function public\.append_consultation_question\(uuid, text, uuid, jsonb\)\s+from public, anon, authenticated/,
|
||
);
|
||
assert.match(
|
||
sql,
|
||
/grant execute on function public\.append_consultation_question\(uuid, text, uuid, jsonb\)\s+to service_role/,
|
||
);
|
||
assert.doesNotMatch(body, /session_physically_full|quota_exceeded|storage_full/);
|
||
});
|
||
|
||
test("conversation quota sum counts only text; physical cap counts whole JSON", () => {
|
||
assert.match(originalSql, /length\(coalesce\(elem->>'thinkingText', ''\)\)/);
|
||
assert.match(originalSql, /elem \? 'thinkingSections'/);
|
||
|
||
const body = functionBody(sql);
|
||
const code = withoutLineComments(body);
|
||
assert.doesNotMatch(code, /thinkingText/);
|
||
assert.doesNotMatch(code, /thinkingSections/);
|
||
assert.match(code, /coalesce\(sum\(length\(coalesce\(elem->>'text', ''\)\)\), 0\)/);
|
||
assert.match(code, /coalesce\(sum\(length\(elem::text\)\), 0\)/);
|
||
assert.match(code, /\(v_physical_chars \+ v_new_physical\) > 1000000/);
|
||
assert.match(sql, /50 rounds × \(~4,000 body \+ ~4,000 thinkingText \+ ~3,000/);
|
||
assert.match(sql, /thinkingSections \+ ~3,000 receipts\) ≈ 700,000\. Headroom → 1,000,000\./);
|
||
});
|
||
|
||
test("both caps still surface as session_full; consult route is unchanged", () => {
|
||
const body = functionBody(sql);
|
||
const fullReturns = body.match(/return query select false, 'session_full'::text;/g) ?? [];
|
||
assert.equal(fullReturns.length, 1);
|
||
assert.match(consultRoute, /error_code === "session_full"/);
|
||
assert.match(consultRoute, /code: "session_full"/);
|
||
assert.doesNotMatch(consultRoute, /session_physically_full|physical_cap|storage_full/);
|
||
assert.match(itemRoute, new RegExp(`sessionSelect = "${SESSION_SELECT}"`));
|
||
});
|
||
|
||
test("measured thinkingSections and receipts stay inside the physical-cap arithmetic", () => {
|
||
const one = JSON.stringify(thinkingPlan(["career"]));
|
||
const two = JSON.stringify(thinkingPlan(["career", "wealth"]));
|
||
const three = JSON.stringify(thinkingPlan(["career", "wealth", "marriage"]));
|
||
assert.ok(one.length >= 1200 && one.length <= 2500, `1-domain sections JSON length ${one.length}`);
|
||
assert.ok(two.length >= 1800 && two.length <= 3500, `2-domain sections JSON length ${two.length}`);
|
||
assert.ok(three.length >= 2400 && three.length <= 4500, `3-domain sections JSON length ${three.length}`);
|
||
|
||
const receipts = typicalReceipts(["career", "wealth", "marriage"]);
|
||
const receiptJson = JSON.stringify({
|
||
techniqueTruth: receipts.techniqueTruth,
|
||
workflowReceipt: receipts.workflowReceipt,
|
||
agentExecutionReceipt: receipts.agentExecutionReceipt,
|
||
});
|
||
const receiptChars = receiptJson.length;
|
||
assert.ok(
|
||
receiptChars <= 4000,
|
||
`typical three-receipt JSON is ${receiptChars} chars; update the 3,000 term and 1,000,000 cap if this is a real stored shape`,
|
||
);
|
||
|
||
const perRound =
|
||
4000
|
||
+ 4000
|
||
+ three.length
|
||
+ receiptChars;
|
||
const fiftyRoundPhysical = 50 * perRound;
|
||
assert.ok(
|
||
fiftyRoundPhysical < 1_000_000,
|
||
`50 × typical stored round (${perRound} chars) = ${fiftyRoundPhysical}; must stay under the physical cap`,
|
||
);
|
||
});
|
||
|
||
test("session-detail JSON at the old ~19-round cap versus the new ~50-round cap", () => {
|
||
const domains = ["career", "wealth", "marriage"] as const;
|
||
const oldCap = sessionDetailPayload(19, domains);
|
||
const newCap = sessionDetailPayload(50, domains);
|
||
const oldJson = JSON.stringify(oldCap);
|
||
const newJson = JSON.stringify(newCap);
|
||
const oldBytes = utf8Bytes(oldJson);
|
||
const newBytes = utf8Bytes(newJson);
|
||
|
||
assert.equal(oldCap.session.messages.length, 38);
|
||
assert.equal(newCap.session.messages.length, 100);
|
||
assert.ok(oldCountedChars(oldCap.session.messages) > 200_000, "19 full rounds already exceeded the old combined quota");
|
||
assert.ok(countedText(newCap.session.messages) >= 200_000, "50 rounds of 100+4000 visible text reach the conversation quota");
|
||
// Measured 2026-09-16 on this fixture: 19-round 562,240 B (0.536 MiB);
|
||
// 50-round 1,479,034 B (1.411 MiB); ratio 2.631.
|
||
assert.ok(oldBytes > 540_000 && oldBytes < 590_000, `19-round detail JSON was ${oldBytes} bytes`);
|
||
assert.ok(newBytes > 1_450_000 && newBytes < 1_510_000, `50-round detail JSON was ${newBytes} bytes`);
|
||
assert.ok(newBytes > oldBytes, "50-round detail JSON must be larger than 19-round");
|
||
|
||
const ratio = newBytes / oldBytes;
|
||
assert.ok(
|
||
ratio > 2.5 && ratio < 2.8,
|
||
`50/19 size ratio was ${ratio.toFixed(3)} (utf8 ${oldBytes} → ${newBytes})`,
|
||
);
|
||
});
|