aki-pro-max 2.3.3

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

@@ -0,0 +1,241 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createWebSessionEventParser } from '../src/web-session-events.mjs';
+
+const encoder = new TextEncoder();
+const bytes = value => encoder.encode(value);
+const jsonFrame = (value, options = {}) => {
+  const payload = JSON.stringify(value);
+  const lines = options.splitDataAt === undefined
+    ? [`data: ${payload}`]
+    : [`data: ${payload.slice(0, options.splitDataAt)}`, `data:${payload.slice(options.splitDataAt)}`];
+  return `${options.event ? `event: ${options.event}\n` : ''}${lines.join('\n')}\n\n`;
+};
+const make = options => createWebSessionEventParser({ maxEventBytes: 4096, maxOutputBytes: 4096, maxObservationBytes: 256, maxEvents: 32, requestedModel: 'public-model', selectedUpstreamModel: 'SELECTED_PIN', allowedObservedModels: ['OBSERVED_PIN'], ...options });
+const feedPieces = (parser, source, cuts) => {
+  const encoded = bytes(source);
+  let start = 0;
+  for (const end of cuts) { parser.feed(encoded.slice(start, end)); start = end; }
+  if (start < encoded.length) parser.feed(encoded.slice(start));
+  return parser.end();
+};
+const throwsCode = (fn, code) => assert.throws(fn, error => error?.code === code && !String(error?.upstreamDetail?.message ?? '').includes('secret-test-value'));
+
+test('fragmented UTF-8, CRLF boundaries, source-backed progress, observations, and explicit DONE succeed', () => {
+  const parser = make();
+  const source = [
+    jsonFrame({ eventType: 'conversation', data: { id: 'conversation-1' } }).replaceAll('\n', '\r\n'),
+    jsonFrame({ eventType: 'planningChunk', data: {} }),
+    jsonFrame({ eventType: 'progressUpdate', data: {} }),
+    jsonFrame({ eventType: 'todoChunk', data: {} }),
+    jsonFrame({ eventType: 'streamingFormat', data: {} }),
+    jsonFrame({ eventType: 'thinkingComplete', data: {} }),
+    jsonFrame({ eventType: 'usage', data: { usageState: 'AVAILABLE', inputTokens: 2, outputTokens: 3, totalTokens: 5 } }),
+    jsonFrame({ eventType: 'textChunk', data: { textContent: 'héllo 🌍', metadata: { model: 'OBSERVED_PIN' } } }),
+    'data: [DONE]\n\n',
+  ].join('');
+  const encoded = bytes(source);
+  const emoji = bytes('🌍');
+  const emojiAt = Buffer.from(encoded).indexOf(Buffer.from(emoji));
+  const result = feedPieces(parser, source, [1, 7, 19, emojiAt + 1, emojiAt + 3, encoded.length - 2]);
+  assert.equal(result.outcome, 'complete_explicit');
+  assert.equal(result.successful, true);
+  assert.equal(result.text, 'héllo 🌍');
+  assert.equal(result.error, null);
+  assert.deepEqual(result.observations.usage, { prompt_tokens: 2, completion_tokens: 3, total_tokens: 5, estimated: false });
+  assert.equal(result.observations.conversationId, 'conversation-1');
+  assert.equal(result.observations.requestedModel, 'public-model');
+  assert.equal(result.observations.selectedUpstreamModel, 'SELECTED_PIN');
+  assert.equal(result.observations.observedUpstreamModel, 'OBSERVED_PIN');
+  assert.equal(result.observations.modelVerification, 'matched');
+  assert.equal(result.observations.parserBufferComplete, true);
+  assert.deepEqual(result.observations.eventTypes, ['conversation', 'planningChunk', 'progressUpdate', 'todoChunk', 'streamingFormat', 'thinkingComplete', 'usage', 'textChunk']);
+});
+
+test('multiple data lines form one JSON payload and an absent model observation stays unobserved', () => {
+  const event = { eventType: 'textChunk', data: { textContent: 'split' } };
+  const frame = jsonFrame(event, { splitDataAt: JSON.stringify(event).indexOf(',') + 1 });
+  const parser = make();
+  parser.feed(bytes(frame));
+  parser.feed(bytes('data: [DONE]\n\n'));
+  const result = parser.end();
+  assert.equal(result.text, 'split');
+  assert.equal(result.successful, true);
+  assert.equal(result.observations.observedUpstreamModel, null);
+  assert.equal(result.observations.modelVerification, 'unobserved');
+});
+
+test('EOF after terminated text frame is explicitly ambiguous and exposes text without successful final', () => {
+  const parser = make();
+  parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'partial answer' } })));
+  const result = parser.end();
+  assert.equal(result.outcome, 'ambiguous_eof');
+  assert.equal(result.successful, false);
+  assert.equal(result.text, 'partial answer');
+  assert.equal(result.error.code, 'upstream_completion_ambiguous');
+  assert.equal(result.observations.parserBufferComplete, true);
+});
+
+test('partial final line, partial frame, and partial UTF-8 EOF never silently flush or succeed', () => {
+  const partialLine = make();
+  partialLine.feed(bytes('data: {"eventType":"textChunk","data":{"textContent":"x"}}'));
+  let result = partialLine.end();
+  assert.equal(result.outcome, 'incomplete_truncated');
+  assert.equal(result.text, '');
+  assert.equal(result.error.code, 'upstream_incomplete_stream');
+
+  const partialFrame = make();
+  partialFrame.feed(bytes('data: {"eventType":"textChunk","data":{"textContent":"x"}}\n'));
+  result = partialFrame.end();
+  assert.equal(result.outcome, 'incomplete_truncated');
+  assert.equal(result.text, '');
+  assert.equal(result.error.code, 'upstream_incomplete_stream');
+
+  const partialUtf8 = make();
+  const encoded = bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: '🌍' } }));
+  const emojiAt = Buffer.from(encoded).indexOf(Buffer.from(bytes('🌍')));
+  partialUtf8.feed(encoded.slice(0, emojiAt + 2));
+  result = partialUtf8.end();
+  assert.equal(result.outcome, 'incomplete_truncated');
+  assert.equal(result.successful, false);
+  assert.equal(result.error.code, 'upstream_invalid_utf8');
+});
+
+test('empty/metadata-only EOF is incomplete and exact DONE may complete an otherwise empty stream', () => {
+  let parser = make();
+  assert.equal(parser.end().outcome, 'incomplete_empty');
+  parser = make();
+  parser.feed(bytes(jsonFrame({ eventType: 'ping', data: {} })));
+  assert.equal(parser.end().outcome, 'incomplete_empty');
+  parser = make();
+  parser.feed(bytes('data: [DONE]\n\n'));
+  const result = parser.end();
+  assert.equal(result.outcome, 'complete_explicit');
+  assert.equal(result.successful, true);
+  assert.equal(result.text, '');
+});
+
+test('captures conversation identifiers repeated on non-conversation chunks', () => {
+  const parser = make();
+  parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'ok', metadata: { conversationId: 'conversation-late' } } })));
+  parser.feed(bytes('data: [DONE]\n\n'));
+  const result = parser.end();
+  assert.equal(result.observations.conversationId, 'conversation-late');
+});
+
+test('unknown events, malformed tool fragments, loop approval, malformed JSON, invalid event values, and invalid terminal forms fail closed', () => {
+  const cases = [
+    [jsonFrame({ eventType: 'futureChunk', data: {} }), 'upstream_unverified_event_shape'],
+    [jsonFrame({ eventType: 'toolCallChunk', data: { secret: 'secret-test-value' } }), 'upstream_tool_fragment_error'],
+    [jsonFrame({ eventType: 'loopApprovalChunk', data: { message: 'secret-test-value' } }), 'upstream_web_session_loop_approval_unsupported'],
+    ['data: {bad json secret-test-value}\n\n', 'upstream_invalid_json'],
+    ['data: []\n\n', 'upstream_invalid_event'],
+    ['event: completion\ndata: [DONE]\n\n', 'upstream_invalid_terminal'],
+  ];
+  for (const [source, code] of cases) {
+    const parser = make();
+    throwsCode(() => parser.feed(bytes(source)), code);
+    const result = parser.end();
+    assert.equal(result.successful, false);
+    assert.equal(result.error.code, code);
+    assert.equal(JSON.stringify(result).includes('secret-test-value'), false);
+  }
+});
+
+test('failure and credit states after text preserve bounded text but never become successful', () => {
+  for (const [event, code] of [
+    [{ eventType: 'failure', data: { message: 'secret-test-value' } }, 'upstream_gateway_failure'],
+    [{ eventType: 'error', data: { error: 'secret-test-value' } }, 'upstream_gateway_failure'],
+    [{ eventType: 'usage', data: { usageState: 'BLOCKED' } }, 'upstream_credit_blocked'],
+    [{ eventType: 'usage', data: { usageState: 'MYSTERY' } }, 'upstream_unknown_credit_state'],
+  ]) {
+    const parser = make();
+    parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'visible' } })));
+    throwsCode(() => parser.feed(bytes(jsonFrame(event))), code);
+    const result = parser.end();
+    assert.equal(result.text, 'visible');
+    assert.equal(result.successful, false);
+    assert.equal(result.error.code, code);
+    assert.equal(JSON.stringify(result).includes('secret-test-value'), false);
+  }
+});
+
+test('model requested/selected/observed remain distinct; missing mapping is unverified and exact configured mismatch fails', () => {
+  let parser = make({ allowedObservedModels: [] });
+  parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'x', metadata: { model: 'UNMAPPED_OBSERVATION' } } })));
+  parser.feed(bytes('data: [DONE]\n\n'));
+  let result = parser.end();
+  assert.equal(result.successful, true);
+  assert.equal(result.observations.modelVerification, 'unverified');
+  assert.equal(result.observations.requestedModel, 'public-model');
+  assert.equal(result.observations.selectedUpstreamModel, 'SELECTED_PIN');
+  assert.equal(result.observations.observedUpstreamModel, 'UNMAPPED_OBSERVATION');
+
+  parser = make();
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'x', metadata: { model: 'WRONG' } } }))), 'upstream_model_mismatch');
+  result = parser.end();
+  assert.equal(result.successful, false);
+  assert.equal(result.text, '');
+  assert.equal(result.observations.modelVerification, 'mismatched');
+
+  parser = make();
+  parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'visible', metadata: { model: 'OBSERVED_PIN' } } })));
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'info', data: { metadata: { model: 'WRONG' } } }))), 'upstream_model_mismatch');
+  result = parser.end();
+  assert.equal(result.text, 'visible');
+  assert.equal(result.successful, false);
+});
+
+test('event, output, observation, and parser-buffer bounds fail without silent truncation', () => {
+  let parser = make({ maxOutputBytes: 4 });
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: '12345' } }))), 'upstream_output_too_large');
+  assert.equal(parser.end().text, '');
+
+  parser = make({ maxObservationBytes: 4 });
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'conversation', data: { id: '12345' } }))), 'upstream_invalid_conversation');
+
+  parser = make({ maxEvents: 1 });
+  parser.feed(bytes(jsonFrame({ eventType: 'ping', data: {} })));
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'info', data: {} }))), 'upstream_event_count_exceeded');
+
+  parser = make({ maxEventBytes: 64 });
+  throwsCode(() => parser.feed(bytes(`data: ${'x'.repeat(80)}\n\n`)), 'upstream_event_too_large');
+});
+
+test('data after terminal, invalid bytes, wrong chunk type, and feed after end are rejected', () => {
+  let parser = make();
+  parser.feed(bytes('data: [DONE]\n\n'));
+  throwsCode(() => parser.feed(bytes(jsonFrame({ eventType: 'ping', data: {} }))), 'upstream_data_after_terminal');
+
+  parser = make();
+  parser.feed(bytes('data: [DONE]\n\ntrailing-secret-test-value'));
+  let result = parser.end();
+  assert.equal(result.successful, false);
+  assert.equal(result.error.code, 'upstream_data_after_terminal');
+  assert.equal(JSON.stringify(result).includes('secret-test-value'), false);
+
+  parser = make();
+  parser.feed(bytes('data: [DONE]\n\n'));
+  throwsCode(() => parser.feed(bytes('data: [DONE]\n\n')), 'upstream_data_after_terminal');
+
+  parser = make();
+  throwsCode(() => parser.feed(new Uint8Array([0xff])), 'upstream_invalid_utf8');
+
+  parser = make();
+  assert.throws(() => parser.feed('data: [DONE]\n\n'), /Uint8Array/);
+  parser.feed(bytes('data: [DONE]\n\n'));
+  parser.end();
+  assert.throws(() => parser.feed(bytes('')), /after end/);
+});
+
+test('502 upstream_model_mismatch carries observedModel on the error object', () => {
+  const parser = make();
+  try {
+    parser.feed(bytes(jsonFrame({ eventType: 'textChunk', data: { textContent: 'x', metadata: { model: 'REAL_WIRELABEL_CLAUDE_TEST' } } })));
+    assert.fail('should have thrown');
+  } catch (err) {
+    assert.equal(err.code, 'upstream_model_mismatch');
+    assert.equal(err.observedModel, 'REAL_WIRELABEL_CLAUDE_TEST');
+    assert.equal(err.observedModelField, 'data.metadata.model');
+  }
+});

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

@@ -0,0 +1,103 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createProviderServer } from '../src/server.mjs';
+import { loadConfig } from '../src/config.mjs';
+import { listen, request, fixture } from './helpers.mjs';
+
+const env = {
+  PROVIDER_API_KEY: 'facade-dummy-key', PROVIDER_MODELS: 'public-model',
+  POSTMAN_TRANSPORT_STRATEGY: 'web_session', POSTMAN_SESSION_COOKIE: 'dummy-cookie-value',
+  POSTMAN_WORKSPACE_SUBDOMAIN: 'fixture-team', POSTMAN_WORKSPACE_ID: 'fixture-workspace',
+  POSTMAN_WEB_SESSION_SELECTED_MODEL: 'GPT_56_SOL', POSTMAN_WEB_SESSION_OBSERVED_MODELS: 'gpt-5.6-sol',
+  REQUEST_TIMEOUT_MS: '1000', MAX_BODY_BYTES: '8192', MAX_EVENT_BYTES: '8192', MAX_OUTPUT_BYTES: '8192',
+  MAX_TOOL_ARGUMENT_BYTES: '1024', MAX_TOOL_RESULT_BYTES: '1024', MAX_TOOLS: '8', MAX_CONCURRENT_REQUESTS: '2',
+};
+const encoder = new TextEncoder();
+const response = ({ events = [], done = true, status = 200, contentType = 'text/event-stream', suffix = '' }) => {
+  const wire = events.map(event => `data: ${JSON.stringify(event)}\n\n`).join('') + (done ? 'data: [DONE]\n\n' : '') + suffix;
+  return new Response(new ReadableStream({ start(controller) { controller.enqueue(encoder.encode(wire)); controller.close(); } }), { status, headers: { 'content-type': contentType } });
+};
+async function withServer(fetchImpl, fn, override = {}) {
+  const server = createProviderServer({ ...loadConfig(env), ...override }, { fetchImpl, logger: { error() {} } });
+  const base = await listen(server);
+  try { await fn(base); } finally { await new Promise(resolve => server.close(resolve)); }
+}
+const body = stream => ({ model: 'public-model', messages: [{ role: 'user', content: 'Reply exactly.' }], stream });
+
+test('explicit web_session returns OpenAI JSON from source-derived observed-DONE fixture and isolates auth headers', async () => {
+  const source = await fixture('web-session-observed-done');
+  let capture;
+  await withServer(async (url, init) => { capture = { url: String(url), init, requestBody: JSON.parse(init.body) }; return response(source); }, async base => {
+    const result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(false) });
+    assert.equal(result.status, 200);
+    const value = await result.json();
+    assert.equal(value.choices[0].message.content, 'PROXY_OBSERVATION_OK');
+    assert.equal(value.choices[0].finish_reason, 'stop');
+    assert.equal(capture.url, 'https://fixture-team.postman.co/_gw/chat');
+    assert.equal(capture.init.headers.cookie, 'postman.sid=dummy-cookie-value');
+    assert.equal(capture.init.headers.authorization, undefined);
+    assert.equal(capture.init.headers['x-access-token'], undefined);
+    assert.equal(JSON.stringify(capture).includes('facade-dummy-key'), false);
+    assert.equal(capture.requestBody.devModeOptions.selectedModel, 'GPT_56_SOL');
+  });
+});
+
+test('explicit web_session returns OpenAI SSE with content, stop, and DONE only after proven upstream DONE', async () => {
+  const source = await fixture('web-session-observed-done');
+  await withServer(() => response(source), async base => {
+    const result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(true) });
+    assert.match(result.headers.get('content-type'), /text\/event-stream/);
+    const wire = await result.text();
+    assert.match(wire, /"content":"PROXY_OBSERVATION_OK"/);
+    assert.match(wire, /"finish_reason":"stop"/);
+    assert.match(wire, /data: \[DONE\]/);
+  });
+});
+
+test('missing model observation is allowed but configured observed mismatch fails before successful response', async () => {
+  await withServer(() => response({ events: [{ eventType: 'textChunk', data: { textContent: 'unobserved' } }] }), async base => {
+    const result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(false) });
+    assert.equal(result.status, 200); assert.equal((await result.json()).choices[0].message.content, 'unobserved');
+  });
+  await withServer(() => response({ events: [{ eventType: 'textChunk', data: { textContent: 'wrong', metadata: { model: 'other-model' } } }] }), async base => {
+    const result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(false) });
+    assert.equal(result.status, 502); assert.equal((await result.json()).error.code, 'upstream_model_mismatch');
+  });
+});
+
+test('error event, ambiguous EOF, wrong content type, and HTTP failure never become successful web_session completions', async () => {
+  const cases = [
+    [() => response({ events: [{ eventType: 'textChunk', data: { textContent: 'partial' } }, { eventType: 'error', data: { error: 'secret-upstream-value' } }] }), 502, 'upstream_gateway_failure'],
+    [() => response({ events: [{ eventType: 'textChunk', data: { textContent: 'partial' } }], done: false }), 502, 'upstream_completion_ambiguous'],
+    [() => response({ events: [], contentType: 'application/json' }), 502, 'upstream_content_type_error'],
+    [() => response({ events: [], status: 401 }), 401, 'upstream_http_error'],
+    [() => response({ events: [], status: 503 }), 503, 'upstream_http_error'],
+  ];
+  for (const [upstream, status, code] of cases) await withServer(upstream, async base => {
+    const result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(false) });
+    assert.equal(result.status, status); const wire = await result.text(); assert.equal(JSON.parse(wire).error.code, code); assert.equal(wire.includes('secret-upstream-value'), false);
+  });
+});
+
+test('web_session accepts declared tools while preserving ingress auth failure isolation', async () => {
+  let calls = 0; let capture;
+  await withServer(async (_url, init) => { calls++; capture=JSON.parse(init.body); return response({ events: [] }); }, async base => {
+    const toolBody = { ...body(false), tools: [{ type: 'function', function: { name: 'lookup', parameters: { type: 'object', properties: {} } } }] };
+    let result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: toolBody });
+    assert.equal(result.status, 200); assert.deepEqual(capture.clientTools.thirdParty['proxy-tools'].tools.map(tool=>tool.name), ['openai__lookup']); assert.equal(calls, 1);
+    result = await request(base, '/v1/chat/completions', { method: 'POST', token: 'wrong-key', body: body(false) });
+    assert.equal(result.status, 401); assert.equal((await result.json()).error.code, 'invalid_api_key'); assert.equal(calls, 1);
+  });
+});
+
+test('web_session propagates client abort to injected upstream', async () => {
+  let upstreamAborted = false;
+  await withServer((url, init) => new Promise((resolve, reject) => init.signal.addEventListener('abort', () => { upstreamAborted = true; reject(init.signal.reason); }, { once: true })), async base => {
+    const controller = new AbortController();
+    const pending = request(base, '/v1/chat/completions', { method: 'POST', token: 'facade-dummy-key', body: body(false), signal: controller.signal });
+    setTimeout(() => controller.abort(new DOMException('fixture abort', 'AbortError')), 20);
+    await assert.rejects(pending, error => error?.name === 'AbortError');
+    await new Promise(resolve => setTimeout(resolve, 20));
+    assert.equal(upstreamAborted, true);
+  });
+});

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

@@ -0,0 +1,52 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createProviderServer } from '../src/server.mjs';
+import { loadConfig } from '../src/config.mjs';
+import { CorrelationStore } from '../src/correlation-store.mjs';
+import { listen, request, fixture } from './helpers.mjs';
+
+const env={PROVIDER_API_KEY:'key',PROVIDER_MODELS:'m',POSTMAN_TRANSPORT_STRATEGY:'web_session',POSTMAN_SESSION_COOKIE:'dummy',POSTMAN_WORKSPACE_SUBDOMAIN:'team',POSTMAN_WORKSPACE_ID:'ws',POSTMAN_WEB_SESSION_SELECTED_MODEL:'GPT',REQUEST_TIMEOUT_MS:'1000',MAX_BODY_BYTES:'65536',MAX_EVENT_BYTES:'65536',MAX_OUTPUT_BYTES:'65536',MAX_TOOL_ARGUMENT_BYTES:'4096',MAX_TOOL_RESULT_BYTES:'4096',MAX_TOOLS:'8',MAX_CONCURRENT_REQUESTS:'4'};
+const config=loadConfig(env); const encoder=new TextEncoder();
+const sse=(events,{done=true}={})=>new Response(new ReadableStream({start(c){for(const e of events)c.enqueue(encoder.encode(`data: ${JSON.stringify(e)}\n\n`));if(done)c.enqueue(encoder.encode('data: [DONE]\n\n'));c.close();}}),{status:200,headers:{'content-type':'text/event-stream'}});
+const tools=[
+ {type:'function',function:{name:'lookup',description:'Lookup',parameters:{type:'object',properties:{q:{type:'string'}},required:['q'],additionalProperties:false}}},
+ {type:'function',function:{name:'count',description:'Count',parameters:{type:'object',properties:{n:{type:'integer'}},required:['n'],additionalProperties:false}}},
+];
+const body=(messages= [{role:'user',content:'use tools'}],more={})=>({model:'m',messages,tools,stream:false,...more});
+async function withServer(fetchImpl,fn,override={}){const server=createProviderServer({...config,...override},{fetchImpl,logger:{error(){}}});const base=await listen(server);try{await fn(base);}finally{await new Promise(r=>server.close(r));}}
+
+test('web_session advertises minimal catalog, buffers grouped fragments, continues with correlated TOOL_RESPONSE, and rejects replay',async()=>{
+ const source=await fixture('web-session-tool-fragments'); let turn=0; const captures=[];
+ await withServer(async(url,init)=>{captures.push(JSON.parse(init.body));return turn++===0?sse(source.events):sse([{eventType:'conversation',data:{id:'conv_source_fixture'}},{eventType:'textChunk',data:{textContent:'final'}}]);},async base=>{
+  const first=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:body()}); assert.equal(first.status,200); const v=await first.json(); assert.equal(v.choices[0].finish_reason,'tool_calls'); const assistant=v.choices[0].message; assert.equal(assistant.tool_calls.length,2); assert.match(assistant.tool_calls[0].id,/^call_pmn_/); assert.deepEqual(JSON.parse(assistant.tool_calls[0].function.arguments),{q:'x'}); assert.deepEqual(JSON.parse(assistant.tool_calls[1].function.arguments),{n:2});
+  assert.deepEqual(captures[0].clientTools.thirdParty['proxy-tools'].tools.map(t=>t.name),['openai__lookup','openai__count']); assert.equal(captures[0].devModeOptions.autoRun,true);
+  const continuation=body([{role:'user',content:'use tools'},assistant,{role:'tool',tool_call_id:assistant.tool_calls[0].id,content:'A'},{role:'tool',tool_call_id:assistant.tool_calls[1].id,content:'B'}]);
+  const second=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:continuation}); assert.equal(second.status,200); assert.equal((await second.json()).choices[0].message.content,'final'); assert.equal(captures[1].input.chatType,'TOOL_RESPONSE'); assert.equal(captures[1].input.toolCallGroupId,'up_group_1'); assert.equal(captures[1].input.toolCallId,'up_call_a'); assert.deepEqual(JSON.parse(captures[1].input.toolResponse).map(x=>x.toolCallId),['up_call_a','up_call_b']);
+  const replay=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:continuation}); assert.equal(replay.status,409); assert.equal((await replay.json()).error.code,'tool_call_already_consumed'); assert.equal(captures.length,2);
+ });
+});
+
+test('AICoworker-style continuation preserves role=tool correlation and dispatches exactly once',async()=>{
+ const source=await fixture('web-session-tool-fragments'); let turn=0; const captures=[];
+ await withServer(async(url,init)=>{captures.push(JSON.parse(init.body));return turn++===0?sse(source.events):sse([{eventType:'conversation',data:{id:'conv_source_fixture'}},{eventType:'textChunk',data:{textContent:'AKI_ONCE'}}]);},async base=>{
+  const first=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:body()}); const assistant=(await first.json()).choices[0].message;
+  const continuation=body([{role:'user',content:'use tools'},assistant,{role:'tool',tool_call_id:assistant.tool_calls[0].id,content:[{type:'text',text:'A'}]},{role:'tool',tool_call_id:assistant.tool_calls[1].id,content:[{type:'text',text:'B'}]}]);
+  const second=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:continuation}); assert.equal(second.status,200); assert.equal((await second.json()).choices[0].message.content,'AKI_ONCE');
+  assert.equal(captures.length,2); assert.equal(captures[1].input.chatType,'TOOL_RESPONSE'); assert.equal(captures[1].input.toolCallId,'up_call_a'); assert.deepEqual(JSON.parse(captures[1].input.toolResponse).map(x=>x.content),['A','B']);
+ });
+});
+
+test('web_session rejects bad arguments, partial group, loop approval, and ambiguous EOF before admission',async()=>{
+ const cases=[
+  [[{eventType:'conversation',data:{id:'c'}},{eventType:'toolCallChunk',data:{id:'a',index:0,name:'openai__count',arguments:'{\"n\":\"bad\"}'}}],{},'upstream_tool_schema_mismatch'],
+  [[{eventType:'conversation',data:{id:'c'}},{eventType:'toolCallChunk',data:{toolCalls:[{id:'a',index:0,name:'openai__lookup',toolCallGroupId:'g',arguments:'{\"q\":\"x\"}'},{id:'b',index:1,name:'openai__count',arguments:'{\"n\":2}' }]}}],{},'upstream_ungrouped_tool_batch'],
+  [[{eventType:'loopApprovalChunk',data:{message:'approve'}}],{},'upstream_web_session_loop_approval_unsupported'],
+  [[{eventType:'conversation',data:{id:'c'}},{eventType:'toolCallChunk',data:{id:'a',index:0,name:'openai__lookup',arguments:'{\"q\":\"x\"}'}}],{done:false},'upstream_completion_ambiguous'],
+ ];
+ for(const [events,opts,code] of cases){let calls=0;await withServer(()=>{calls++;return sse(events,opts);},async base=>{const r=await request(base,'/v1/chat/completions',{method:'POST',token:'key',body:body()});const expectedStatus=code==='upstream_web_session_loop_approval_unsupported'?400:502;assert.equal(r.status,expectedStatus);assert.equal((await r.json()).error.code,code);assert.equal(calls,1);});}
+});
+
+test('correlation binds principal, strategy and origin without mutating pending record',()=>{
+ const store=new CorrelationStore(); const common={principalId:'p',workspaceId:'ws',model:'m',transportStrategy:'web_session',transportOrigin:'https://team.postman.co',conversationId:'c',transcript:[{role:'user',content:'u'},{role:'assistant',content:'',tool_calls:[{id:'up',type:'function',function:{name:'lookup',arguments:'{\"q\":\"x\"}'}}]}],toolsBinding:{tools:[tools[0]],toolChoice:'auto'},catalogMetadata:{strategy:'web_session'},calls:[{upstreamToolCallId:'up',upstreamGroupId:null,originalName:'lookup',argumentsJson:'{\"q\":\"x\"}',schemaHash:'s'}]}; const g=store.admit(common); const result=[{toolCallId:g.calls[0].publicToolCallId,content:'ok'}]; const claim={principalId:'p',results:result,workspaceId:'ws',model:'m',transportStrategy:'web_session',transportOrigin:'https://team.postman.co',transcript:g.transcript,toolsBinding:common.toolsBinding,catalogMetadata:common.catalogMetadata};
+ assert.throws(()=>store.claim({...claim,transportStrategy:'access_token'}),e=>e.code==='continuation_strategy_mismatch'); assert.equal(g.state,'PENDING'); assert.throws(()=>store.claim({...claim,transportOrigin:'https://other.postman.co'}),e=>e.code==='continuation_origin_mismatch'); assert.equal(g.state,'PENDING'); assert.throws(()=>store.claim({...claim,principalId:'other'}),e=>e.code==='unknown_tool_call');
+});

package/version.json

@@ -0,0 +1,8 @@
+{
+  "latest": "2.3.3",
+  "minSupported": "2.3.0",
+  "releasedAt": "2026-09-13T06:30:00Z",
+  "releaseNotesUrl": "https://github.com/khangtudo/aki-pro-max/releases/tag/v2.3.3",
+  "installPackage": "aki-pro-max",
+  "updateCommand": "npm install -g aki-pro-max@latest"
+}