aki-pro-max 2.3.3

package/test/full-ingress/run-full-ingress.mjs

@@ -0,0 +1,207 @@
+import http from 'node:http';
+import net from 'node:net';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { spawn, spawnSync } from 'node:child_process';
+import { once } from 'node:events';
+import assert from 'node:assert/strict';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createProviderServer } from '../../src/server.mjs';
+import { DatabaseSync } from 'node:sqlite';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const serviceRoot = path.resolve(here, '../..');
+const workspaceRoot = path.resolve(serviceRoot, '../..');
+const routerRoot = process.env.NINEROUTER_ROOT || path.join(workspaceRoot, 'tmp/9router-pinned-17c4cc7');
+const expectReplayFix = process.env.EXPECT_REPLAY_FIX === '1';
+const runRoot = path.join(serviceRoot, '.full-ingress-run');
+const dataDir = path.join(runRoot, '9router-data');
+const nextLogPath = path.join(runRoot, 'next.log');
+const resultPath = path.join(runRoot, 'result.json');
+const providerId = 'openai-compatible-chat-full-ingress';
+const prefix = 'pmnfull';
+const model = 'fixture-model';
+const clientKey = 'sk-client-full-ingress-offline';
+const facadeKey = 'sk-facade-full-ingress-offline';
+const upstreamToken = 'pstmn-offline-sentinel';
+const startedPids = [];
+let nextChild;
+
+await fs.rm(runRoot, { recursive: true, force: true });
+await fs.mkdir(dataDir, { recursive: true });
+
+const freePort = () => new Promise((resolve, reject) => {
+  const s = net.createServer(); s.unref(); s.on('error', reject);
+  s.listen(0, '127.0.0.1', () => { const p = s.address().port; s.close(() => resolve(p)); });
+});
+const sse = (res, frames, delayDone = 0) => {
+  res.writeHead(200, { 'content-type': 'text/event-stream', connection: 'close' });
+  for (const frame of frames) res.write(`event: message\ndata: ${JSON.stringify(frame)}\n\n`);
+  const done = () => res.end('data: [DONE]\n\n');
+  delayDone ? setTimeout(done, delayDone) : done();
+};
+
+const captures = [];
+let toolSequence = 0;
+let cancelObserved = false;
+const rawMock = http.createServer(async (req, res) => {
+  const chunks = []; for await (const chunk of req) chunks.push(chunk);
+  const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  captures.push({ url: req.url, method: req.method, headers: req.headers, body });
+  assert.equal(req.socket.remoteAddress === '127.0.0.1' || req.socket.remoteAddress === '::ffff:127.0.0.1', true);
+  assert.equal(req.headers['x-access-token'], upstreamToken);
+  const query = String(body?.input?.query || '');
+  if (query.includes('cancel-fixture')) {
+    req.on('close', () => { cancelObserved = true; });
+    res.on('close', () => { if (!res.writableEnded) cancelObserved = true; });
+    sse(res, [{ eventType: 'conversation', data: { id: 'conv_cancel' } }], 10000);
+    return;
+  }
+  if (body?.input?.chatType === 'TOOL_RESPONSE') {
+    sse(res, [{ eventType: 'conversation', data: { id: 'conv_tool' } }, { eventType: 'textChunk', data: { textContent: 'native final' } }]);
+    return;
+  }
+  if (query.includes('tool-fixture')) {
+    toolSequence++;
+    sse(res, [
+      { eventType: 'conversation', data: { id: 'conv_tool' } },
+      { eventType: 'toolCallChunk', data: { id: 'call_raw', index: 0, name: 'openai__lookup', toolCallGroupId: 'group_raw' } },
+      { eventType: 'toolCallChunk', data: { id: 'call_raw', index: 0, arguments: '{"q":' } },
+      { eventType: 'toolCallChunk', data: { id: 'call_raw', index: 0, arguments: '"x"}' } },
+    ]);
+    return;
+  }
+  const text = query.includes('sse-fixture') ? 'hello sse' : 'hello json';
+  sse(res, [{ eventType: 'conversation', data: { id: 'conv_text' } }, { eventType: 'textChunk', data: { textContent: text } }]);
+});
+rawMock.listen(0, '127.0.0.1'); await once(rawMock, 'listening');
+const rawBase = `http://127.0.0.1:${rawMock.address().port}`;
+
+const facadeConfig = {
+  host: '127.0.0.1', port: 0, apiKey: facadeKey, upstreamToken, workspaceId: 'ws_full_ingress',
+  upstreamOrigin: 'https://offline.invalid', chatPath: '/chat', appVersion: 'full-ingress/0.1', models: [model],
+  timeoutMs: 15000, maxBodyBytes: 1024 * 1024, maxEventBytes: 1024 * 1024, maxOutputBytes: 1024 * 1024,
+  maxToolArgumentBytes: 1024 * 1024, maxTools: 64, maxConcurrent: 8, exposeHealthDetails: false,
+  correlationEnabled: true, principalKey: 'full-ingress-principal', credentialSlotId: 'full-ingress-slot',
+  maxToolResultBytes: 1024 * 1024, correlationPendingTtlMs: 30000, correlationTerminalTtlMs: 30000,
+  correlationInflightTtlMs: 30000, correlationMaxGroups: 100, correlationMaxCalls: 100, correlationMaxBytes: 1024 * 1024,
+};
+const facade = createProviderServer(facadeConfig, {
+  logger: { error(line) { process.stderr.write(`[facade] ${line}\n`); } },
+  fetchImpl: (_url, init) => fetch(`${rawBase}/chat`, init),
+});
+facade.listen(0, '127.0.0.1'); await once(facade, 'listening');
+const facadeBase = `http://127.0.0.1:${facade.address().port}`;
+
+const commonEnv = {
+  ...process.env, DATA_DIR: dataDir, NINEROUTER_ROOT: routerRoot, NEXT_TELEMETRY_DISABLED: '1',
+  FULL_INGRESS_PROVIDER_ID: providerId, FULL_INGRESS_PREFIX: prefix, FULL_INGRESS_FACADE_BASE: facadeBase,
+  FULL_INGRESS_PROVIDER_API_KEY: facadeKey, FULL_INGRESS_CLIENT_API_KEY: clientKey,
+  HTTP_PROXY: 'http://127.0.0.1:9', HTTPS_PROXY: 'http://127.0.0.1:9', ALL_PROXY: 'http://127.0.0.1:9',
+  NO_PROXY: '127.0.0.1,localhost,::1', NODE_NO_WARNINGS: '1',
+};
+const seed = spawnSync(process.execPath, ['--loader', pathToFileURL(path.join(here, 'alias-loader.mjs')).href, path.join(here, 'seed-9router.mjs')], {
+  cwd: routerRoot, env: commonEnv, encoding: 'utf8', timeout: 30000,
+});
+assert.equal(seed.status, 0, `seed failed\n${seed.stdout}\n${seed.stderr}`);
+
+const nextPort = await freePort();
+const nextBin = path.join(routerRoot, 'node_modules/next/dist/bin/next');
+const out = await fs.open(nextLogPath, 'w');
+nextChild = spawn(process.execPath, [nextBin, 'dev', '--webpack', '--hostname', '127.0.0.1', '--port', String(nextPort)], {
+  cwd: routerRoot, env: commonEnv, stdio: ['ignore', out.fd, out.fd], windowsHide: true,
+});
+startedPids.push(nextChild.pid);
+const nextBase = `http://127.0.0.1:${nextPort}`;
+
+async function waitReady() {
+  const deadline = Date.now() + 90000; let last = '';
+  while (Date.now() < deadline) {
+    if (nextChild.exitCode !== null) throw new Error(`Next exited ${nextChild.exitCode}`);
+    try { const r = await fetch(`${nextBase}/api/health`); last = `${r.status} ${await r.text()}`; if (r.status < 500) return; } catch (e) { last = e.message; }
+    await new Promise(r => setTimeout(r, 500));
+  }
+  throw new Error(`Next readiness timeout: ${last}`);
+}
+
+const request = (body, options = {}) => fetch(`${nextBase}/v1/chat/completions`, {
+  method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${clientKey}`, ...(options.headers || {}) },
+  body: JSON.stringify(body), signal: options.signal,
+});
+
+const observations = {};
+try {
+  await waitReady();
+  let before = captures.length;
+  const jsonRes = await request({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'json-fixture' }], stream: false });
+  assert.equal(jsonRes.status, 200); const jsonBody = await jsonRes.json();
+  assert.equal(jsonBody.choices[0].message.content, 'hello json'); assert.equal(captures.length, before + 1);
+  assert.equal(captures.at(-1).body.devModeOptions.selectedModel, model);
+  observations.json = { status: jsonRes.status, content: jsonBody.choices[0].message.content, selectedModel: captures.at(-1).body.devModeOptions.selectedModel };
+
+  before = captures.length;
+  const sseRes = await request({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'sse-fixture' }], stream: true });
+  assert.equal(sseRes.status, 200); const wire = await sseRes.text();
+  assert.match(wire, /hello sse/); assert.match(wire, /"finish_reason":"stop"/); assert.match(wire, /data: \[DONE\]/); assert.equal(captures.length, before + 1);
+  observations.sse = { status: sseRes.status, hasText: true, hasStop: true, hasDone: true };
+
+  const tool = { type: 'function', function: { name: 'lookup', description: 'lookup', parameters: { type: 'object', properties: { q: { type: 'string' } }, required: ['q'], additionalProperties: false } } };
+  before = captures.length;
+  const firstRes = await request({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'tool-fixture' }], tools: [tool], stream: false });
+  assert.equal(firstRes.status, 200); const firstBody = await firstRes.json(); const assistant = firstBody.choices[0].message; const call = assistant.tool_calls[0];
+  assert.match(call.id, /^call_pmn_/); assert.notEqual(call.id, 'call_raw');
+  const continuation = { model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'tool-fixture' }, assistant, { role: 'tool', tool_call_id: call.id, content: 'lookup-result' }], tools: [tool], stream: false };
+  const secondRes = await request(continuation); assert.equal(secondRes.status, 200); assert.equal((await secondRes.json()).choices[0].message.content, 'native final');
+  assert.equal(captures.length, before + 2); const toolCapture = captures.at(-1); assert.equal(toolCapture.body.input.chatType, 'TOOL_RESPONSE'); assert.equal(toolCapture.body.input.toolCallGroupId, 'group_raw'); assert.equal(toolCapture.body.input.toolResponses[0].toolCallId, 'call_raw');
+  observations.tool = { first: firstRes.status, continuation: secondRes.status, syntheticCallId: call.id, rawRequests: 2 };
+
+  before = captures.length;
+  const missing = await fetch(`${nextBase}/v1/chat/completions`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'x' }] }) });
+  const invalid = await fetch(`${nextBase}/v1/chat/completions`, { method: 'POST', headers: { 'content-type': 'application/json', authorization: 'Bearer wrong' }, body: JSON.stringify({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'x' }] }) });
+  const badModel = await request({ model: 'unconfigured-prefix/nope', messages: [{ role: 'user', content: 'x' }], stream: false });
+  assert.equal(missing.status, 401); assert.equal(invalid.status, 401); assert.notEqual(badModel.status, 200); assert.equal(captures.length, before);
+  observations.failures = { missingAuth: missing.status, invalidAuth: invalid.status, badModel: badModel.status, rawRequests: 0 };
+
+  before = captures.length; const controller = new AbortController();
+  const cancelResponse = await request({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'cancel-fixture' }], stream: true }, { signal: controller.signal });
+  const pendingBody = cancelResponse.text();
+  setTimeout(() => controller.abort(new DOMException('full ingress cancellation', 'AbortError')), 500);
+  await assert.rejects(pendingBody, e => e?.name === 'AbortError');
+  await new Promise(r => setTimeout(r, 800));
+  assert.equal(captures.length, before + 1);
+  observations.cancel = { clientAbort: true, rawRequestObserved: true, rawDisconnectObserved: cancelObserved };
+
+  before = captures.length;
+  const replayRes = await request(continuation); const replayBody = await replayRes.json();
+  if (expectReplayFix) {
+    assert.equal(replayRes.status, 409); assert.equal(replayBody?.error?.code, 'tool_call_already_consumed'); assert.equal(captures.length, before);
+    const replayAgainRes = await request(continuation); const replayAgainBody = await replayAgainRes.json();
+    assert.equal(replayAgainRes.status, 409); assert.equal(replayAgainBody?.error?.code, 'tool_call_already_consumed'); assert.equal(captures.length, before);
+    const db = new DatabaseSync(path.join(dataDir, 'db/data.sqlite'), { readOnly: true });
+    const row = db.prepare('SELECT data FROM providerConnections WHERE provider = ?').get(providerId); db.close();
+    const connectionState = JSON.parse(row.data);
+    assert.ok(connectionState.testStatus == null || connectionState.testStatus === 'active'); assert.equal(connectionState.lastError ?? null, null); assert.equal(connectionState.errorCode ?? null, null); assert.ok(connectionState.backoffLevel == null || connectionState.backoffLevel === 0);
+    assert.equal(Object.keys(connectionState).some(key => key.startsWith('modelLock_') && connectionState[key]), false);
+    const freshBefore = captures.length;
+    const freshRes = await request({ model: `${prefix}/${model}`, messages: [{ role: 'user', content: 'fresh-after-replay' }], stream: false });
+    assert.equal(freshRes.status, 200); assert.equal(captures.length, freshBefore + 1);
+    observations.replayFix = { facadeStatus: 409, replayStatuses: [replayRes.status, replayAgainRes.status], embeddedCodes: [replayBody.error.code, replayAgainBody.error.code], extraRawRequests: 0, connectionState, freshStatus: freshRes.status, freshRawRequests: 1 };
+  } else {
+    assert.equal(replayRes.status, 503); assert.equal(captures.length, before);
+    assert.match(replayBody?.error?.message || JSON.stringify(replayBody), /tool_call_already_consumed/);
+    observations.replayGap = { facadeStatus: 409, nextIngressStatus: replayRes.status, embeddedCode: 'tool_call_already_consumed', extraRawRequests: 0, classification: 'pinned 9router account-fallback converts deterministic facade 409 into 503 and locks the selected account' };
+  }
+
+  const result = { ok: true, routerCommit: '17c4cc76877bd1755030a8414f8d0083f48dcccf', routerRoot, expectReplayFix, dataDir, nextBase, facadeBase, rawBase, startedPids, captures: captures.length, toolSequence, observations, seedStdout: seed.stdout.trim() };
+  await fs.writeFile(resultPath, JSON.stringify(result, null, 2));
+  console.log(JSON.stringify(result, null, 2));
+} finally {
+  if (nextChild && nextChild.exitCode === null) {
+    if (process.platform === 'win32') spawnSync('taskkill', ['/PID', String(nextChild.pid), '/T', '/F'], { encoding: 'utf8' });
+    else nextChild.kill('SIGTERM');
+    await Promise.race([once(nextChild, 'exit'), new Promise(r => setTimeout(r, 5000))]).catch(() => {});
+  }
+  await out.close().catch(() => {});
+  await new Promise(r => facade.close(r));
+  await new Promise(r => rawMock.close(r));
+}

package/test/full-ingress/seed-9router.mjs

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const root = process.env.NINEROUTER_ROOT;
+if (!root || !process.env.DATA_DIR) throw new Error('NINEROUTER_ROOT and DATA_DIR are required');
+const localDb = await import(pathToFileURL(path.join(root, 'src/lib/localDb.js')).href);
+
+const nodeId = process.env.FULL_INGRESS_PROVIDER_ID || 'openai-compatible-chat-full-ingress';
+const prefix = process.env.FULL_INGRESS_PREFIX || 'pmnfull';
+const facadeBase = process.env.FULL_INGRESS_FACADE_BASE;
+const providerApiKey = process.env.FULL_INGRESS_PROVIDER_API_KEY;
+const clientApiKey = process.env.FULL_INGRESS_CLIENT_API_KEY;
+if (!facadeBase || !providerApiKey || !clientApiKey) throw new Error('Missing full ingress seed variables');
+
+await localDb.updateSettings({
+  requireApiKey: true, requireLogin: false, enableObservability: false,
+  outboundProxyEnabled: false, rtkEnabled: false, headroomEnabled: false,
+  cavemanEnabled: false, ponytailEnabled: false, pxpipeEnabled: false,
+  capacityAdapter: {
+    vision: { enabled: false, roundRobin: false, models: [] },
+    pdf: { enabled: false, roundRobin: false, models: [] },
+    audioInput: { enabled: false, roundRobin: false, models: [] },
+    videoInput: { enabled: false, roundRobin: false, models: [] },
+  },
+});
+await localDb.createProviderNode({ id: nodeId, type: 'openai-compatible', name: 'Offline Postman Full Ingress', prefix, apiType: 'chat', baseUrl: `${facadeBase}/v1` });
+await localDb.createProviderConnection({
+  provider: nodeId, authType: 'apikey', name: 'Offline Postman Full Ingress', apiKey: providerApiKey,
+  isActive: true, testStatus: 'active', priority: 1,
+  providerSpecificData: { baseUrl: `${facadeBase}/v1`, apiType: 'chat', connectionProxyEnabled: false },
+});
+const db = await import(pathToFileURL(path.join(root, 'src/lib/db/driver.js')).href);
+const adapter = await db.getAdapter();
+adapter.run('INSERT INTO apiKeys(id, key, name, machineId, isActive, createdAt) VALUES(?, ?, ?, ?, ?, ?)',
+  ['full-ingress-client-key', clientApiKey, 'Full ingress client', 'offline-fixture', 1, new Date().toISOString()]);
+console.log(JSON.stringify({ seeded: true, dataDir: process.env.DATA_DIR, nodeId, prefix, facadeBase }));

package/test/helpers.mjs

@@ -0,0 +1,9 @@
+import assert from 'node:assert/strict';
+import { once } from 'node:events';
+import { readFile } from 'node:fs/promises';
+export const config=Object.freeze({host:'127.0.0.1',port:0,apiKey:'ingress-secret',upstreamToken:'upstream-secret',workspaceId:'ws_fixture',upstreamOrigin:'https://gateway.example.test',chatPath:'/chat',appVersion:'test',models:['fixture-model'],timeoutMs:1000,maxBodyBytes:4096,maxEventBytes:4096,maxOutputBytes:4096,maxToolArgumentBytes:1024,maxTools:8,maxConcurrent:2,exposeHealthDetails:false});
+export function sseResponse(events,{status=200,contentType='text/event-stream',done=true,chunks=null}={}){const text=events.map(({event='message',data})=>`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`).join('')+(done?'data: [DONE]\n\n':'');const encoder=new TextEncoder();let parts=chunks?chunks.map(([a,b])=>encoder.encode(text.slice(a,b))):[encoder.encode(text)];return new Response(new ReadableStream({pull(c){if(parts.length)c.enqueue(parts.shift());else c.close();}}),{status,headers:{'content-type':contentType}});}
+export async function listen(server){server.listen(0,'127.0.0.1');await once(server,'listening');return `http://127.0.0.1:${server.address().port}`;}
+export async function request(base,path,{method='GET',token='ingress-secret',body,signal}={}){return fetch(`${base}${path}`,{method,signal,headers:{authorization:`Bearer ${token}`,...(body?{'content-type':'application/json'}:{})},body:body?JSON.stringify(body):undefined});}
+export async function fixture(name){return JSON.parse(await readFile(new URL(`./fixtures/${name}.json`,import.meta.url),'utf8'));}
+export async function json(response,status=200){assert.equal(response.status,status);return response.json();}

package/test/issue-closure-harness.test.mjs

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { verifyIssueClosure } from '../scripts/verify-issue-closure.mjs';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const load = (name) => JSON.parse(fs.readFileSync(path.join(ROOT, name), 'utf8'));
+const clone = (value) => structuredClone(value);
+const baseline = () => ({ claude: load('CLAUDE-LIVE-TOOLS-EVIDENCE.json'), trace: load('FULL-TRACE-EVIDENCE.json') });
+
+function expectReject(mutator, code) {
+  const evidence = baseline();
+  mutator(evidence);
+  assert.throws(() => verifyIssueClosure(evidence), (error) => error instanceof Error && error.message === code);
+}
+
+test('closure harness accepts the committed Claude and PMN evidence', () => {
+  const result = verifyIssueClosure(baseline());
+  assert.equal(result.verdict, 'PASS');
+  assert.equal(result.controls.failover, false);
+  assert.equal(result.controls.cpxActive, true);
+});
+
+test('fail-closed: retry/failover and stale-probe branches reject', () => {
+  expectReject(({ claude }) => { claude.policy.retry = true; }, 'claude_retry_must_be_false');
+  expectReject(({ claude }) => { claude.policy.failover = true; }, 'claude_failover_must_be_false');
+  expectReject(({ claude }) => { claude.startedWithPriorCurrentProbeAttempts = 1; }, 'claude_probe_not_fresh');
+});
+
+test('fail-closed: Claude malformed tool arguments and incomplete continuation reject', () => {
+  expectReject(({ claude }) => { claude.branches[1].initial.argumentsValid = false; }, 'claude_arguments_invalid');
+  expectReject(({ claude }) => { claude.branches[1].initial.argumentsDiagnostic.keyCount = 1; }, 'claude_arguments_not_empty');
+  expectReject(({ claude }) => { claude.branches[1].continuation.facadeStatus = 502; }, 'claude_continuation_not_200');
+  expectReject(({ claude }) => { claude.branches[1].finalMatchesMarker = false; }, 'claude_final_marker_mismatch');
+});
+
+test('fail-closed: PMN attribution cannot silently resolve to CPX or an inactive connection', () => {
+  expectReject(({ trace }) => { trace.rows.find((row) => row.connectionId.includes('6706879a')).connectionId = '27b72dc7-4a15-4b8a-815b-71f7839e5f2b'; }, 'pmn_row_count_invalid');
+  expectReject(({ trace }) => { trace.connections['6706879a-9897-4b2a-9142-728ca64276d4'].isActive = 0; }, 'pmn_connection_inactive');
+  expectReject(({ trace }) => { trace.connections['27b72dc7-4a15-4b8a-815b-71f7839e5f2b'].isActive = 0; }, 'cpx_not_active_during_trace');
+});
+
+test('fail-closed: ambiguous or mismatched PMN marker rows reject', () => {
+  expectReject(({ trace }) => { trace.rows.find((row) => row.connectionId.includes('6706879a')).completionTokens = 5; }, 'pmn_marker_token_count_invalid');
+  expectReject(({ trace }) => { trace.rows.push(clone(trace.rows.find((row) => row.connectionId.includes('6706879a')))); }, 'pmn_row_count_invalid');
+  expectReject(({ trace }) => { trace.rows = trace.rows.filter((row) => !row.connectionId.includes('27b72dc7')); }, 'cpx_control_row_missing');
+});

package/test/model-thinking.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { resolveUpstreamModel, isThinkingModel } from '../src/web-session-request.mjs';
+
+test('resolveUpstreamModel maps all 4 models and their thinking variants', () => {
+  assert.equal(resolveUpstreamModel('gpt-5.6-sol'), 'GPT_56_SOL');
+  assert.equal(resolveUpstreamModel('gpt-5.6-sol-thinking'), 'GPT_56_SOL');
+  assert.equal(resolveUpstreamModel('gpt-5.6-terra'), 'GPT_56_TERRA');
+  assert.equal(resolveUpstreamModel('gpt-5.6-terra-thinking'), 'GPT_56_TERRA');
+  assert.equal(resolveUpstreamModel('claude-opus-4-8'), 'CLAUDE_OPUS_48_BEDROCK');
+  assert.equal(resolveUpstreamModel('claude-opus-4-7'), 'CLAUDE_OPUS_47_BEDROCK');
+  assert.equal(resolveUpstreamModel('unknown', 'FALLBACK'), 'FALLBACK');
+});
+
+test('isThinkingModel identifies -thinking suffix', () => {
+  assert.equal(isThinkingModel('gpt-5.6-sol-thinking'), true);
+  assert.equal(isThinkingModel('gpt-5.6-sol'), false);
+  assert.equal(isThinkingModel('claude-opus-4-8-thinking'), true);
+  assert.equal(resolveUpstreamModel('claude-opus-4-8'), 'CLAUDE_OPUS_48_BEDROCK');
+});

package/test/protocol.test.mjs

@@ -0,0 +1,16 @@
+import test from 'node:test';import assert from 'node:assert/strict';
+import { parseSSE } from '../src/sse.mjs';import { createRawEventAdapter } from '../src/postman-events.mjs';import { createResponseState } from '../src/openai-response.mjs';import { canonicalEvents } from '../src/transport.mjs';import { config,fixture,sseResponse } from './helpers.mjs';
+async function* fragments(value){for(const x of value)yield new TextEncoder().encode(x);}
+const adapter=(limit=1024)=>createRawEventAdapter({toolNameMap:new Map([['openai__lookup','lookup']]),maxToolArgumentBytes:limit,maxOutputBytes:limit});
+const toolRequest={model:'fixture-model',toolNameMap:new Map([['openai__lookup','lookup']]),toolSchemaMap:new Map([['lookup',{type:'object',properties:{q:{type:'string'}},required:['q'],additionalProperties:false}]])};
+test('SSE parser handles arbitrary chunk splits and exposes [DONE] once',async()=>{const text='event: message\ndata: {"x":1}\n\ndata: [DONE]\n\ndata: {"eventType":"textChunk","data":{"textContent":"late"}}\n\n';const got=[];for await(const f of parseSSE(fragments([text.slice(0,7),text.slice(7,21),text.slice(21)]),1024))got.push(f);assert.equal(got.length,3);assert.equal(got[0].event,'message');assert.equal(got[1].data,'[DONE]');});
+test('source-derived text frames assemble at the [DONE] boundary',async()=>{const fx=await fixture('text');const a=adapter();const state=createResponseState({model:'fixture-model'});for(const f of fx.frames)for(const e of a.adapt({event:f.event,data:JSON.stringify(f.data)}))state.apply(e);for(const e of a.finish())state.apply(e);const r=state.result();assert.equal(r.choices[0].message.content,'hello');assert.equal(r.choices[0].finish_reason,'stop');assert.equal(r.usage.total_tokens,4);});
+test('fragmented tool call preserves id index name args and validates only at completion',async()=>{const fx=await fixture('tool');const a=adapter();const state=createResponseState(toolRequest);for(const f of fx.frames)for(const e of a.adapt({event:f.event,data:JSON.stringify(f.data)}))state.apply(e);for(const e of a.finish())state.apply(e);const r=state.result();assert.equal(r.choices[0].finish_reason,'tool_calls');assert.deepEqual(r.choices[0].message.tool_calls[0],{id:'call_fixture',type:'function',function:{name:'lookup',arguments:'{"q":"x"}'}});});
+test('empty object arguments are accepted when schema permits them',()=>{const a=adapter();const state=createResponseState({...toolRequest,toolSchemaMap:new Map([['lookup',{type:'object',properties:{},additionalProperties:false}]])});for(const e of a.adapt({event:'message',data:JSON.stringify({eventType:'toolCallChunk',data:{id:'c',index:0,name:'openai__lookup',arguments:''}})}))state.apply(e);for(const e of a.finish())state.apply(e);assert.equal(state.result().choices[0].message.tool_calls[0].function.arguments,'');});
+test('truncated and malformed completed tool arguments fail closed',()=>{for(const value of ['{"q":','not-json']){const a=adapter();const state=createResponseState(toolRequest);for(const e of a.adapt({event:'message',data:JSON.stringify({eventType:'toolCallChunk',data:{id:'c',index:0,name:'openai__lookup',arguments:value}})}))state.apply(e);assert.throws(()=>{for(const e of a.finish())state.apply(e);},/invalid JSON arguments/);}});
+test('unknown shape malformed JSON oversize and incomplete boundaries fail closed',async()=>{const a=adapter(3);assert.throws(()=>a.adapt({event:'message',data:'{"eventType":"finish","data":{"finishReason":"stop"}}'}),/Unsupported/);assert.throws(()=>a.adapt({event:'message',data:'not-json'}),/malformed/);assert.throws(()=>a.adapt({event:'message',data:'{"eventType":"textChunk","data":{"textContent":"long"}}'}),/exceeds/);await assert.rejects(async()=>{for await(const _ of parseSSE(fragments(['data: '+ 'x'.repeat(100)]),10)){}},/exceeds/);});
+test('canonical transport ignores text/tool/double markers after exact [DONE] and rejects EOF before it',async()=>{const request={model:'fixture-model',messages:[{role:'user',content:'x'}],tools:[],toolNameMap:new Map(),toolSchemaMap:new Map(),toolResults:[],toolChoice:'none'};const events=[];const raw='event: message\ndata: {"eventType":"textChunk","data":{"textContent":"literal [DONE] is content"}}\n\ndata: [DONE]\n\nevent: message\ndata: {"eventType":"toolCallChunk","data":{"id":"late","index":0,"name":"unknown","arguments":"{}"}}\n\ndata: [DONE]\n\n';for await(const e of canonicalEvents(request,config,{fetchImpl:async()=>new Response(raw,{headers:{'content-type':'text/event-stream'}}),signal:new AbortController().signal}))events.push(e);assert.deepEqual(events.filter(e=>e.type==='text_delta').map(e=>e.text),['literal [DONE] is content']);assert.equal(events.filter(e=>e.type==='finish').length,1);assert.equal(events.some(e=>e.type==='tool_call_start'),false);await assert.rejects(async()=>{for await(const _ of canonicalEvents(request,config,{fetchImpl:async()=>sseResponse([],{done:false}),signal:new AbortController().signal})){}},/before \[DONE\]/);});
+const frame=data=>({event:'message',data:JSON.stringify(data)});
+test('source-backed failure envelopes are classified and sanitized without finish',()=>{for(const [value,code,status] of [[{result:'failure',message:'Bearer secret-value arbitrary body'},'upstream_gateway_failure',502],[{eventType:'error',errorType:'TOOL_VALIDATION_ERROR',message:'secret-value'},'upstream_tool_validation_error',400],[{eventType:'error',data:{errorType:'LLM_STREAM_ERROR',message:'secret-value'}},'upstream_stream_error',502]]){const a=adapter();assert.throws(()=>a.adapt(frame(value)),error=>error.code===code&&error.status===status&&!error.message.includes('secret-value'));assert.deepEqual(a.finish(),[{type:'finish',reason:'stop'}]);}});
+test('credit states preserve known distinctions and unknown states fail closed',()=>{const available=adapter().adapt(frame({eventType:'usage',data:{usageState:'AVAILABLE',inputTokens:2,outputTokens:3}}));assert.equal(available[0].usage.total_tokens,5);assert.throws(()=>adapter().adapt(frame({eventType:'usage',data:{usageState:'BLOCKED',blockedUntil:'2026-09-06T19:17:37.905Z'}})),error=>error.code==='upstream_credit_blocked'&&error.status===400&&!error.message.includes('2026-'));assert.throws(()=>adapter().adapt(frame({eventType:'usage',data:{usageState:'MYSTERY'}})),error=>error.code==='upstream_unknown_credit_state'&&error.status===502);});
+test('transport failures before text after text and during tools never yield finish',async()=>{const request={model:'fixture-model',messages:[{role:'user',content:'x'}],tools:[],toolNameMap:new Map([['openai__lookup','lookup']]),toolSchemaMap:new Map(),toolResults:[],toolChoice:'none'};for(const frames of [[{result:'failure'}],[{eventType:'textChunk',data:{textContent:'partial'}},{eventType:'error',data:{errorType:'LLM_STREAM_ERROR'}}],[{eventType:'conversation',data:{id:'conv'}},{eventType:'toolCallChunk',data:{id:'u',index:0,name:'openai__lookup',toolCallGroupId:'g'}},{eventType:'error',errorType:'TOOL_VALIDATION_ERROR'}]]){const events=[];await assert.rejects(async()=>{for await(const e of canonicalEvents(request,config,{fetchImpl:async()=>sseResponse(frames),signal:new AbortController().signal}))events.push(e);});assert.equal(events.some(event=>event.type==='finish'),false);}});

package/test/request.test.mjs

@@ -0,0 +1,10 @@
+import test from 'node:test';import assert from 'node:assert/strict';
+import { normalizeOpenAIRequest } from '../src/openai.mjs';import { buildPostmanRequest } from '../src/postman-request.mjs';import { config } from './helpers.mjs';
+const tool={type:'function',function:{name:'lookup',description:'Lookup',parameters:{type:'object',properties:{q:{type:'string'}},required:['q'],additionalProperties:false}}};
+test('normalizes tools with original-name map and full history raw request',()=>{const r=normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'system',content:'s'},{role:'user',content:'u'}],tools:[tool]},config);assert.equal(r.toolNameMap.get('openai__lookup'),'lookup');const raw=buildPostmanRequest(r,config);assert.equal(raw.url.href,'https://gateway.example.test/chat');assert.equal(raw.init.headers['x-access-token'],'upstream-secret');const body=JSON.parse(raw.init.body);assert.equal(body.input.chatType,'USER_QUERY');assert.equal(JSON.parse(body.input.query).format,'openai-full-history-v1');assert.equal(body.clientTools.thirdParty['openai-client'].tools[0].name,'openai__lookup');});
+test('tool result continuation fails closed without trusted upstream correlation',()=>{const r=normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'user',content:'u'},{role:'assistant',content:null,tool_calls:[{id:'c1',type:'function',function:{name:'lookup',arguments:'{"q":"x"}'}}]},{role:'tool',tool_call_id:'c1',content:'ok'}],tools:[tool],tool_choice:{type:'function',function:{name:'lookup'}}},config);assert.throws(()=>buildPostmanRequest(r,config),error=>error.code==='unknown_tool_call'&&error.status===400);});
+test('orphan result invalid args and unsupported surface reject',()=>{assert.throws(()=>normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'tool',tool_call_id:'x',content:'a'}]},config),/unknown tool call/);assert.throws(()=>normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'user',content:'u'}],n:2},config),/Only n=1/);});
+
+test('operator catalog metadata is conditional cloned and request body cannot override it',()=>{const configured={...config,platform:'DESKTOP_CUSTOM',nativeToolsHash:'catalog:authoritative-1',excludedTools:Object.freeze(['readFile','webSearch'])};const source={model:'fixture-model',messages:[{role:'user',content:'u'}],tools:[tool],platform:'USER_OVERRIDE',nativeToolsHash:'USER_HASH',excludedTools:['USER_TOOL']};const r=normalizeOpenAIRequest(source,configured);const before=structuredClone(source);const raw=buildPostmanRequest(r,configured);const body=JSON.parse(raw.init.body);assert.equal(body.platform,'DESKTOP_CUSTOM');assert.equal(body.clientTools.nativeToolsHash,'catalog:authoritative-1');assert.deepEqual(body.clientTools.excludedTools,['readFile','webSearch']);assert.ok(body.clientTools.thirdParty['openai-client']);assert.deepEqual(source,before);body.clientTools.excludedTools.push('mutated');assert.deepEqual(configured.excludedTools,['readFile','webSearch']);});
+test('unset catalog metadata omits hash and preserves OpenAI namespace query and platform defaults',()=>{const r=normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'user',content:'u'}],tools:[tool]},config);const body=JSON.parse(buildPostmanRequest(r,config).init.body);assert.equal(body.platform,'OPENAI_COMPATIBLE_ADAPTER');assert.equal('nativeToolsHash' in body.clientTools,false);assert.deepEqual(body.clientTools.excludedTools,[]);assert.deepEqual(Object.keys(body.clientTools.thirdParty),['openai-client']);assert.equal(JSON.parse(body.input.query).format,'openai-full-history-v1');});
+test('initial and continuation envelopes use identical configured catalog metadata',()=>{const configured={...config,platform:'DESKTOP_CUSTOM',nativeToolsHash:'catalog:authoritative-1',excludedTools:['readFile']};const r=normalizeOpenAIRequest({model:'fixture-model',messages:[{role:'user',content:'u'}],tools:[tool]},configured);const group={conversationId:'conv',upstreamGroupId:'grp',calls:[{upstreamToolCallId:'up',originalName:'lookup'}]};const initial=JSON.parse(buildPostmanRequest(r,configured).init.body);const next=JSON.parse(buildPostmanRequest(r,configured,{group,orderedResults:[{content:'ok'}]}).init.body);assert.equal(next.input.chatType,'TOOL_RESPONSE');assert.equal(next.platform,initial.platform);assert.deepEqual(next.clientTools,initial.clientTools);});

package/test/session-store.test.mjs

@@ -0,0 +1,20 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { SessionMappingStore } from '../src/session-store.mjs';
+
+test('SessionMappingStore stores, retrieves, resets, and expires conversations', () => {
+  const store = new SessionMappingStore({ ttlMs: 100 });
+  store.setConversationId('ss-1', 'conv-123');
+  assert.equal(store.getConversationId('ss-1'), 'conv-123');
+  assert.equal(store.getConversationId('ss-2'), null);
+
+  // Reset
+  store.reset('ss-1');
+  assert.equal(store.getConversationId('ss-1'), null);
+
+  // Expiry
+  store.setConversationId('ss-3', 'conv-456');
+  assert.equal(store.getConversationId('ss-3'), 'conv-456');
+  store.sweep(Date.now() + 200);
+  assert.equal(store.getConversationId('ss-3'), null);
+});

package/test/web-session-builder.test.mjs

@@ -0,0 +1,124 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { loadConfig, webSessionUrl } from '../src/config.mjs';
+import { normalizeOpenAIRequest } from '../src/openai.mjs';
+import { buildPostmanRequest } from '../src/postman-request.mjs';
+import { buildWebSessionTextRequest } from '../src/web-session-request.mjs';
+import { createProviderServer } from '../src/server.mjs';
+import { listen, request } from './helpers.mjs';
+
+const base = {
+  PROVIDER_API_KEY: 'facade-test-dummy',
+  PROVIDER_MODELS: 'public-model',
+  POSTMAN_TRANSPORT_STRATEGY: 'web_session',
+  POSTMAN_SESSION_COOKIE: 'session-test-dummy',
+  POSTMAN_WORKSPACE_SUBDOMAIN: 'team-7',
+  POSTMAN_WORKSPACE_ID: 'workspace-test-dummy',
+  POSTMAN_WEB_SESSION_SELECTED_MODEL: 'UPSTREAM_PIN_TEST',
+  MAX_BODY_BYTES: '4096',
+};
+const config = () => loadConfig(base);
+const normalized = (body = {}) => normalizeOpenAIRequest({ model: 'public-model', messages: [{ role: 'system', content: 'be exact' }, { role: 'user', content: 'hello' }], ...body }, config());
+
+test('web_session config derives one exact HTTPS Postman chat URL', () => {
+  const c = config();
+  const url = webSessionUrl(c);
+  assert.equal(url.href, 'https://team-7.postman.co/_gw/chat');
+  assert.equal(url.origin, 'https://team-7.postman.co');
+  assert.equal(url.hostname, 'team-7.postman.co');
+});
+
+test('strategy is closed, web-session fields require explicit strategy, and credentials are exclusive', () => {
+  assert.throws(() => loadConfig({ ...base, POSTMAN_TRANSPORT_STRATEGY: 'other' }), /must be access_token or web_session/);
+  const { POSTMAN_TRANSPORT_STRATEGY, ...implicit } = base;
+  assert.throws(() => loadConfig(implicit), /STRATEGY is required/);
+  assert.throws(() => loadConfig({ ...base, POSTMAN_ACCESS_TOKEN: 'token-test-dummy' }), /web_session forbids/);
+  assert.throws(() => loadConfig({ ...base, POSTMAN_ORIGIN: 'https:\/\/gateway.example.test' }), /web_session forbids/);
+  assert.throws(() => loadConfig({ ...base, POSTMAN_CHAT_PATH: '/chat' }), /web_session forbids/);
+  const legacy = loadConfig({ PROVIDER_API_KEY: 'a', PROVIDER_MODELS: 'm', POSTMAN_ACCESS_TOKEN: 'b', POSTMAN_WORKSPACE_ID: 'w', POSTMAN_ORIGIN: 'https://gateway.example.test' });
+  assert.equal(legacy.transportStrategy, 'access_token');
+  assert.equal(legacy.transportStrategyExplicit, false);
+});
+
+test('cookie and subdomain reject injection, whole-cookie syntax, lookalikes, and bounds', () => {
+  for (const value of ['x\rY: z', 'x\ny', 'x y', 'x;y', 'x,y', 'x\\y', '\0x', 'é', 'x'.repeat(4097)]) assert.throws(() => loadConfig({ ...base, POSTMAN_SESSION_COOKIE: value }), /POSTMAN_SESSION_COOKIE/);
+  assert.equal(loadConfig({ ...base, POSTMAN_SESSION_COOKIE: 'x'.repeat(4096) }).webSessionCookie.length, 4096);
+  for (const value of ['foo.bar', 'foo.postman.co', 'postman.co', 'foo%2ebar', 'Foo', 'foo_bar', '-foo', 'foo-', 'foo/', 'foo/bar', 'foo:443', 'foo:80', 'foo@bar', 'xn--fsq', 'é', 'x'.repeat(64)]) assert.throws(() => loadConfig({ ...base, POSTMAN_WORKSPACE_SUBDOMAIN: value }), /POSTMAN_WORKSPACE_SUBDOMAIN/);
+});
+
+test('pure builder returns exact allowlisted URL/init and keeps facade/token headers separate', () => {
+  const raw = buildWebSessionTextRequest(normalized(), config());
+  assert.equal(raw.url.href, 'https://team-7.postman.co/_gw/chat');
+  assert.equal(raw.init.method, 'POST');
+  assert.equal(raw.init.redirect, 'error');
+  assert.deepEqual(Object.keys(raw.init.headers).sort(), ['accept', 'content-type', 'cookie', 'origin', 'referer', 'user-agent', 'x-pstmn-req-service'].sort());
+  assert.equal(raw.init.headers.cookie, 'postman.sid=session-test-dummy');
+  assert.equal(raw.init.headers.origin, 'https://team-7.postman.co');
+  assert.equal(raw.init.headers.referer, 'https://team-7.postman.co/');
+  assert.equal(raw.init.headers.authorization, undefined);
+  assert.equal(raw.init.headers['x-access-token'], undefined);
+  assert.equal(JSON.stringify(raw).includes('facade-test-dummy'), false);
+});
+
+test('body is deterministic, config-owned, fresh text-only, and does not mutate caller input', () => {
+  const source = { model: 'public-model', messages: [{ role: 'user', content: 'hello' }], platform: 'ATTACK', workspaceId: 'ATTACK', conversationId: 'ATTACK', cookie: 'ATTACK', origin: 'ATTACK', selectedModel: 'ATTACK', devModeOptions: { selectedModel: 'ATTACK' } };
+  const before = structuredClone(source);
+  const c = config();
+  const request = normalizeOpenAIRequest(source, c);
+  const a = buildWebSessionTextRequest(request, c);
+  const b = buildWebSessionTextRequest(request, c);
+  assert.equal(a.init.body, b.init.body);
+  assert.deepEqual(source, before);
+  const body = JSON.parse(a.init.body);
+  assert.equal(body.platform, 'WEB');
+  assert.equal(body.mandatoryContext.workspaceId, 'workspace-test-dummy');
+  assert.equal(body.input.conversationId, null);
+  assert.equal(body.devModeOptions.selectedModel, 'UPSTREAM_PIN_TEST');
+  assert.equal(body.devModeOptions.isParallelToolCallingSupported, false);
+  assert.deepEqual(body.clientTools, { native: [] });
+  assert.equal(a.init.body.includes('ATTACK'), false);
+  const query = JSON.parse(body.input.query);
+  assert.equal(query.format, 'openai-full-history-v1');
+  assert.deepEqual(query.messages, [{ role: 'user', content: 'hello' }]);
+});
+
+test('web-session builder advertises tools, preserves assistant tool history, and rejects uncorrelated results and named tool choice', () => {
+  const c = config();
+  const tool = { type: 'function', function: { name: 'lookup', parameters: { type: 'object', properties: {} } } };
+  const built=buildWebSessionTextRequest(normalizeOpenAIRequest({ model: 'public-model', messages: [{ role: 'user', content: 'x' }], tools: [tool] }, c), c);
+  assert.deepEqual(JSON.parse(built.init.body).clientTools.thirdParty['proxy-tools'].tools.map(value=>value.name), ['openai__lookup']);
+  const fake = { ...normalized(), messages: [{ role: 'assistant', content: '', tool_calls: [{ id: 'x' }] }], toolChoice: 'none' };
+  const historyBody=JSON.parse(buildWebSessionTextRequest(fake, c).init.body);
+  const historyQuery=JSON.parse(historyBody.input.query);
+  assert.equal(historyQuery.messages[0].role,'assistant');
+  assert.equal(historyQuery.messages[0].tool_calls[0].id,'x');
+  assert.throws(() => buildWebSessionTextRequest({ ...normalized(), toolResults: [{ toolCallId: 'x', content: 'y' }] }, c), error=>error.code==='unknown_tool_call');
+  assert.throws(() => buildWebSessionTextRequest({ ...normalized(), toolChoice: {type:'function',name:'lookup'} }, c), /named tool_choice/);
+});
+
+test('serialized body obeys MAX_BODY_BYTES and optional app version is validated/allowlisted', () => {
+  const c = loadConfig({ ...base, MAX_BODY_BYTES: '1024', POSTMAN_APP_VERSION: 'app-test-1' });
+  const raw = buildWebSessionTextRequest(normalizeOpenAIRequest({ model: 'public-model', messages: [{ role: 'user', content: 'ok' }] }, c), c);
+  assert.equal(raw.init.headers['x-app-version'], 'app-test-1');
+  assert.throws(() => buildWebSessionTextRequest(normalizeOpenAIRequest({ model: 'public-model', messages: [{ role: 'user', content: 'x'.repeat(2000) }] }, c), c), error => error.code === 'request_too_large' && error.status === 413);
+  assert.throws(() => loadConfig({ ...base, POSTMAN_APP_VERSION: 'bad\r\nheader' }), /POSTMAN_APP_VERSION/);
+});
+
+test('existing live request dispatcher rejects web_session before fetch/event parsing', () => {
+  assert.throws(() => buildPostmanRequest(normalized(), config()), error => error.code === 'web_session_transport_not_active' && error.status === 400);
+});
+
+test('provider server activates web_session only when the explicit strategy is configured', async () => {
+  const c = { ...config(), timeoutMs: 1000, maxConcurrent: 1, correlationPendingTtlMs: 1000, correlationTerminalTtlMs: 1000, correlationInflightTtlMs: 1000, correlationMaxGroups: 10, correlationMaxCalls: 10, correlationMaxBytes: 4096, maxEventBytes: 4096, maxOutputBytes: 4096, maxToolArgumentBytes: 1024, maxToolResultBytes: 1024, exposeHealthDetails: false };
+  let fetchCalls = 0;
+  const server = createProviderServer(c, { fetchImpl: async () => { fetchCalls++; return new Response('data: {"eventType":"textChunk","data":{"textContent":"active"}}\n\ndata: [DONE]\n\n', { status: 200, headers: { 'content-type': 'text/event-stream' } }); }, logger: { error() {} } });
+  const baseUrl = await listen(server);
+  try {
+    const response = await request(baseUrl, '/v1/chat/completions', { method: 'POST', token: 'facade-test-dummy', body: { model: 'public-model', messages: [{ role: 'user', content: 'hello' }] } });
+    assert.equal(response.status, 200);
+    assert.equal((await response.json()).choices[0].message.content, 'active');
+    assert.equal(fetchCalls, 1);
+  } finally {
+    await new Promise(resolve => server.close(resolve));
+  }
+});