aki-pro-max 2.3.3

package/src/index.mjs

@@ -0,0 +1,4 @@
+import { loadConfig } from './config.mjs';
+import { createProviderServer } from './server.mjs';
+const config=loadConfig();const server=createProviderServer(config);server.listen(config.port,config.host,()=>{const address=server.address();console.log(JSON.stringify({event:'listening',host:config.host,port:typeof address==='object'?address.port:config.port,upstream_verified:false}));});
+const shutdown=signal=>{server.close(()=>process.exit(0));setTimeout(()=>process.exit(1),5000).unref();};process.on('SIGINT',()=>shutdown('SIGINT'));process.on('SIGTERM',()=>shutdown('SIGTERM'));

package/src/openai-response.mjs

@@ -0,0 +1,72 @@
+import { randomUUID } from 'node:crypto';
+import { upstream } from './errors.mjs';
+import { validateValue } from './schema.mjs';
+import { canonicalHash } from './canonical.mjs';
+
+export function createResponseState(request) {
+  const id = `chatcmpl_${randomUUID().replaceAll('-', '')}`;
+  const created = Math.floor(Date.now() / 1000);
+  let content = '', finishReason = null, usage = null, conversationId = null, admittedGroup = null;
+  const calls = new Map();
+  const finalizeTools = () => {
+    for (const call of calls.values()) {
+      let args;
+      try { args = JSON.parse(call.function.arguments || '{}'); }
+      catch { throw upstream(`Upstream tool ${call.function.name} returned invalid JSON arguments.`, 'upstream_invalid_tool_arguments'); }
+      const schema = request.toolSchemaMap?.get(call.function.name);
+      if (!schema) throw upstream('Upstream returned an undeclared tool.', 'upstream_unregistered_tool');
+      try { validateValue(args, schema); }
+      catch { throw upstream(`Upstream tool ${call.function.name} arguments do not match the caller schema.`, 'upstream_tool_schema_mismatch'); }
+    }
+  };
+  const orderedCalls = () => [...calls.entries()].sort(([a], [b]) => a - b).map(([, value]) => value);
+  const message = () => { const value = { role: 'assistant', content: content || null }; if (calls.size) value.tool_calls = orderedCalls().map(call => ({ id: call.id, type: 'function', function: { ...call.function } })); return value; };
+  return {
+    id, created, model: request.model,
+    apply(event) {
+      if (event.type === 'response_start') conversationId = event.conversationId;
+      else if (event.type === 'text_delta') content += event.text;
+      else if (event.type === 'tool_call_start') calls.set(event.index, { id: event.id, upstreamId: event.id, upstreamGroupId: event.groupId ?? null, type: 'function', function: { name: event.name, arguments: '' } });
+      else if (event.type === 'tool_args_delta') { const call = calls.get(event.index); if (!call) throw upstream('Tool argument delta arrived before tool start.', 'upstream_tool_fragment_error'); call.function.arguments += event.arguments; }
+      else if (event.type === 'usage') usage = event.usage;
+      else if (event.type === 'finish') { finishReason = event.reason; if (event.reason === 'tool_calls') finalizeTools(); }
+    },
+    hasTools() { return calls.size > 0; },
+    admit(store, context) {
+      if (!calls.size) return null;
+      finalizeTools();
+      if (!conversationId) throw upstream('Upstream tool calls are missing a conversation ID.', 'upstream_invalid_conversation');
+      const values = orderedCalls();
+      const groupValues = values.map(call => call.upstreamGroupId);
+      const groups = new Set(groupValues);
+      if (values.length > 1 && (groups.size !== 1 || groupValues[0] === null)) throw upstream('Upstream returned tool calls without one common group.', 'upstream_ungrouped_tool_batch');
+      const upstreamGroupId = groupValues[0] ?? null;
+      admittedGroup = store.admit({ ...context, conversationId, upstreamGroupId, calls: values.map(call => ({ upstreamToolCallId: call.upstreamId, upstreamGroupId: call.upstreamGroupId, originalName: call.function.name, argumentsJson: call.function.arguments, schemaHash: canonicalHash(request.toolSchemaMap.get(call.function.name)) })) });
+      admittedGroup.calls.forEach((stored, index) => { values[index].id = stored.publicToolCallId; });
+      return admittedGroup;
+    },
+    toolChunks() {
+      return orderedCalls().flatMap((call, index) => [
+        { id, object: 'chat.completion.chunk', created, model: request.model, choices: [{ index: 0, delta: { tool_calls: [{ index, id: call.id, type: 'function', function: { name: call.function.name, arguments: '' } }] }, finish_reason: null }] },
+        ...(call.function.arguments ? [{ id, object: 'chat.completion.chunk', created, model: request.model, choices: [{ index: 0, delta: { tool_calls: [{ index, function: { arguments: call.function.arguments } }] }, finish_reason: null }] }] : []),
+      ]);
+    },
+    chunk(event) {
+      const base = { id, object: 'chat.completion.chunk', created, model: request.model, choices: [{ index: 0, delta: {}, finish_reason: null }] }; const choice = base.choices[0];
+      if (event.type === 'response_start') choice.delta = { role: 'assistant', content: '' };
+      else if (event.type === 'text_delta') choice.delta = { content: event.text };
+      else if (event.type === 'tool_call_start' || event.type === 'tool_args_delta') return null;
+      else if (event.type === 'usage') return { ...base, choices: [], usage: event.usage };
+      else if (event.type === 'finish') { choice.delta = {}; choice.finish_reason = event.reason; }
+      else return null;
+      return base;
+    },
+    result() {
+      if (!finishReason) finishReason = calls.size ? 'tool_calls' : 'stop';
+      if (calls.size) finalizeTools();
+      return { id, object: 'chat.completion', created, model: request.model, choices: [{ index: 0, message: message(), finish_reason: finishReason }], usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }, usage_estimated: true };
+    },
+    message,
+    admittedGroup() { return admittedGroup; },
+  };
+}

package/src/openai.mjs

@@ -0,0 +1,104 @@
+import { createHash } from 'node:crypto';
+import { ProviderError, invalid } from './errors.mjs';
+import { validateSchemaDefinition, validateValue } from './schema.mjs';
+const namePattern = /^[A-Za-z0-9_-]{1,64}$/;
+const text = (content, field) => {
+  if (typeof content === 'string') return content;
+  if (content === null || content === undefined) return '';
+  if (Array.isArray(content)) {
+    // Extract any text blocks, thinking blocks, or tool results gracefully
+    const parts = [];
+    for (const p of content) {
+      if (!p || typeof p !== 'object') continue;
+      if (typeof p.text === 'string') parts.push(p.text);
+      else if (typeof p.content === 'string') parts.push(p.content);
+      else if (typeof p.thinking === 'string') parts.push(p.thinking);
+      else if (p.type === 'toolCall' || p.type === 'tool_call') parts.push(`[Tool Call: ${p.name || p.function?.name || ''}]`);
+    }
+    return parts.join('\n');
+  }
+  return String(content);
+};
+function normalizeTools(input, maxTools) {
+  if (input === undefined) return { tools: [], nameMap: new Map(), schemaMap: new Map(), binding: [] };
+  if (!Array.isArray(input) || input.length > maxTools) throw invalid(`tools must be an array with at most ${maxTools} entries.`, 'invalid_tools');
+  const used = new Set(), nameMap = new Map(), schemaMap = new Map(), binding = [];
+  const tools = input.map((entry, index) => {
+    if (entry?.type !== 'function' || !entry.function || typeof entry.function !== 'object') throw invalid(`tools[${index}] must be a function tool.`, 'invalid_tool');
+    const { name, description = '', parameters = { type: 'object', properties: {} } } = entry.function;
+    if (!namePattern.test(name)) throw invalid(`tools[${index}].function.name is invalid.`, 'invalid_tool_name');
+    validateSchemaDefinition(parameters, `$.tools[${index}].function.parameters`);
+    let registered = `openai__${name}`;
+    if (registered.length > 64 || used.has(registered)) registered = `openai__${createHash('sha256').update(name).digest('hex').slice(0,40)}`;
+    if (used.has(registered)) throw invalid('Tool names collide after normalization.', 'tool_name_collision');
+    used.add(registered); nameMap.set(registered, name); schemaMap.set(name, parameters);
+    binding.push({ type: 'function', function: { name, description, parameters } });
+    return { name: registered, originalName: name, description: `${name}: ${description || 'Client-declared function tool.'}`, parameters };
+  });
+  return { tools, nameMap, schemaMap, binding };
+}
+function normalizeMessages(messages, schemaMap, maxToolResultBytes) {
+  if (!Array.isArray(messages) || !messages.length) throw invalid('messages must be a non-empty array.', 'invalid_messages');
+  const normalized = [], declaredCalls = new Map(); const toolResults = [];
+  let suffixStart = messages.length; while (suffixStart > 0 && messages[suffixStart - 1]?.role === 'tool') suffixStart--;
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message || typeof message !== 'object' || !['system','developer','user','assistant','tool'].includes(message.role)) throw invalid(`messages[${i}].role is invalid.`, 'invalid_message_role');
+    if (message.role === 'tool') {
+      if (typeof message.tool_call_id !== 'string' || !message.tool_call_id) throw invalid(`messages[${i}].tool_call_id is required.`, 'invalid_tool_result');
+      const content = text(message.content, `messages[${i}].content`);
+      if (Buffer.byteLength(content) > maxToolResultBytes) throw new ProviderError(413, 'Tool result exceeds the configured limit.', 'invalid_request_error', 'tool_result_too_large');
+      if (i >= suffixStart) toolResults.push({ toolCallId: message.tool_call_id, content });
+      normalized.push({ role: 'tool', tool_call_id: message.tool_call_id, content });
+      continue;
+    }
+    const item = { role: message.role, content: text(message.content, `messages[${i}].content`) };
+    if (message.role === 'assistant' && message.tool_calls !== undefined) {
+      if (!Array.isArray(message.tool_calls) || !message.tool_calls.length) throw invalid(`messages[${i}].tool_calls must be non-empty.`, 'invalid_tool_calls');
+      item.tool_calls = message.tool_calls.map((call, j) => {
+        if (call?.type !== 'function' || typeof call.id !== 'string' || !call.id || !call.function || !namePattern.test(call.function.name) || typeof call.function.arguments !== 'string') throw invalid(`messages[${i}].tool_calls[${j}] is invalid.`, 'invalid_tool_call');
+        let args; try { args = JSON.parse(call.function.arguments || '{}'); } catch { throw invalid(`messages[${i}].tool_calls[${j}] has invalid JSON arguments.`, 'invalid_tool_arguments'); }
+        const schema = schemaMap.get(call.function.name); if (schema) validateValue(args, schema);
+        declaredCalls.set(call.id, call.function.name);
+        return { id: call.id, type: 'function', function: { name: call.function.name, arguments: call.function.arguments } };
+      });
+    }
+    normalized.push(item);
+  }
+  if (toolResults.length) {
+    const finalBlockIds = new Set();
+    for (let index = normalized.length - toolResults.length - 1; index >= 0; index--) {
+      const message = normalized[index];
+      if (message.role === 'assistant' && message.tool_calls?.length) { for (const call of message.tool_calls) finalBlockIds.add(call.id); break; }
+    }
+    for (const result of toolResults) if (!finalBlockIds.has(result.toolCallId) && !result.toolCallId.startsWith('call_pmn_') && !result.toolCallId.startsWith('callpmn')) {
+      throw invalid(`Tool result references unknown tool call ${result.toolCallId}.`, 'unknown_tool_call');
+    }
+  }
+  return { messages: normalized, prefix: normalized.slice(0, normalized.length - toolResults.length), toolResults };
+}
+function normalizeToolChoice(value, binding) {
+  if (value === undefined) return binding.length ? 'auto' : 'none';
+  if (['none','auto','required'].includes(value)) return value;
+  if (value?.type === 'function' && namePattern.test(value.function?.name) && binding.some(t => t.function.name === value.function.name)) return { type: 'function', name: value.function.name };
+  throw invalid('tool_choice is invalid or references an unknown tool.', 'invalid_tool_choice');
+}
+export function normalizeOpenAIRequest(body, config) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) throw invalid('Request body must be a JSON object.');
+  if (typeof body.model !== 'string') throw invalid('model is required.', 'invalid_model');
+
+  // Preserve OpenAI assistant tool_calls and role=tool messages verbatim so the
+  // correlation store can resolve each result exactly once. Content arrays are
+  // already normalized safely by text(); rewriting tool results as user turns
+  // loses tool_call_id and restarts the initial tool-selection phase.
+  const normalizedTools = normalizeTools(body.tools, config.maxTools);
+  const history = normalizeMessages(body.messages, normalizedTools.schemaMap, config.maxToolResultBytes ?? config.maxBodyBytes);
+  if (body.n !== undefined && body.n !== 1) throw invalid('Only n=1 is supported.', 'unsupported_n');
+  if (body.response_format !== undefined) throw invalid('response_format is not verified for this upstream.', 'unsupported_response_format');
+  if (body.parallel_tool_calls !== undefined && body.parallel_tool_calls !== true) throw invalid('parallel_tool_calls=false is not supported.', 'unsupported_parallel_tool_calls');
+  for (const [key,min,max] of [['temperature',0,2],['top_p',0,1]]) if (body[key] !== undefined && (typeof body[key] !== 'number' || body[key] < min || body[key] > max)) throw invalid(`${key} is out of range.`, `invalid_${key}`);
+  if (body.max_tokens !== undefined && (!Number.isSafeInteger(body.max_tokens) || body.max_tokens <= 0)) throw invalid('max_tokens must be a positive integer.', 'invalid_max_tokens');
+  const toolChoice = normalizeToolChoice(body.tool_choice, normalizedTools.binding);
+  return { model: body.model, messages: history.messages, transcriptPrefix: history.prefix, tools: normalizedTools.tools, toolsBinding: { tools: normalizedTools.binding, toolChoice }, toolNameMap: normalizedTools.nameMap, toolSchemaMap: normalizedTools.schemaMap, toolResults: history.toolResults, toolChoice, stream: Boolean(body.stream), maxTokens: body.max_tokens ?? null, temperature: body.temperature ?? null, topP: body.top_p ?? null, stop: body.stop ?? null, user: typeof body.user === 'string' ? body.user : null };
+}
+export function buildTranscript(messages) { return messages.map(m => m.role === 'assistant' && m.tool_calls ? { role: 'assistant', content: m.content, tool_calls: m.tool_calls } : m.role === 'tool' ? { role: 'tool', tool_call_id: m.tool_call_id, content: m.content } : { role: m.role, content: m.content }); }

package/src/postman-events.mjs

@@ -0,0 +1,43 @@
+import { upstream } from './errors.mjs';
+const eventName=(event,frame)=>typeof event.eventType==='string'?event.eventType:frame.event||'message';
+const object=value=>value&&typeof value==='object'&&!Array.isArray(value)?value:null;
+function failureFor(event,frame){
+  const data=object(event.data);const envelope=data||event;const name=eventName(event,frame);
+  const type=typeof (event.errorType??data?.errorType)==='string'?(event.errorType??data.errorType):null;
+  if(type==='TOOL_VALIDATION_ERROR')return upstream('Postman gateway rejected the advertised tool catalog.','upstream_tool_validation_error',400);
+  if(type==='LLM_STREAM_ERROR')return upstream('Postman model stream was interrupted.','upstream_stream_error');
+  if(type)return upstream('Postman gateway reported an upstream model error.','upstream_model_error');
+  if(envelope.result==='failure'||name==='failure')return upstream('Postman gateway reported a request failure.','upstream_gateway_failure');
+  if(name==='error'||event.error||data?.error)return upstream('Postman gateway reported an upstream model error.','upstream_model_error');
+  return null;
+}
+function usageFor(data){
+  if(typeof data.usageState==='string'&&data.usageState==='BLOCKED')throw upstream('Postman AI credit access is blocked.','upstream_credit_blocked',400);
+  if(typeof data.usageState==='string'&&data.usageState!=='AVAILABLE')throw upstream('Postman gateway reported an unknown credit state.','upstream_unknown_credit_state');
+  const usage={prompt_tokens:Number.isSafeInteger(data.inputTokens)?data.inputTokens:0,completion_tokens:Number.isSafeInteger(data.outputTokens)?data.outputTokens:0};usage.total_tokens=usage.prompt_tokens+usage.completion_tokens;return [{type:'usage',usage,estimated:true}];
+}
+export function createRawEventAdapter({toolNameMap,maxToolArgumentBytes,maxOutputBytes}) {
+  const tools=new Map(); let outputBytes=0;
+  const addOutput=value=>{outputBytes+=Buffer.byteLength(value||'');if(outputBytes>maxOutputBytes)throw upstream('Upstream output exceeds the configured limit.','upstream_output_too_large');};
+  return {
+    adapt(frame){let event;try{event=JSON.parse(frame.data);}catch{throw upstream('Postman gateway sent malformed SSE JSON.','upstream_invalid_json');}if(!event||typeof event!=='object'||Array.isArray(event))throw upstream('Postman gateway sent an invalid SSE event.','upstream_invalid_event');
+      const failure=failureFor(event,frame);if(failure)throw failure;
+      const name=eventName(event,frame),data=event.data??{};
+      if(name==='conversation'){if(typeof data.id!=='string'||!data.id)throw upstream('Conversation event is missing an ID.','upstream_invalid_conversation');return [{type:'response_start',conversationId:data.id}];}
+      if(name==='textChunk'){if(typeof data.textContent!=='string')throw upstream('textChunk has an unverified shape.','upstream_unverified_event_shape');addOutput(data.textContent);return [{type:'text_delta',text:data.textContent}];}
+      if(name==='toolCallChunk'||name==='tool_call') return this.tool(data);
+      if(name==='usage')return usageFor(data);
+      if(name==='thinkingChunk'||name==='thinkingComplete'||name==='usageUpdate'||name==='ping') return [];
+      throw upstream(`Unsupported Postman SSE event type: ${name}.`,'upstream_unverified_event_shape');
+    },
+    tool(data){const chunks=data?.toolCalls||(data?.toolCall?[data.toolCall]:data?.id||data?.index!==undefined?[data]:null);if(!Array.isArray(chunks))throw upstream('Unsupported Postman tool event shape.','upstream_unverified_tool_shape');const out=[];
+      for(const chunk of chunks){if(!chunk||typeof chunk!=='object'||(chunk.id!==undefined&&(typeof chunk.id!=='string'||!chunk.id))||(chunk.index!==undefined&&(!Number.isInteger(chunk.index)||chunk.index<0)))throw upstream('Invalid Postman tool fragment correlation.','upstream_tool_fragment_error');
+        const byId=chunk.id?[...tools.entries()].find(([,v])=>v.id===chunk.id):null,byIndex=chunk.index!==undefined?[...tools.entries()].find(([,v])=>v.index===chunk.index):null;if(byId&&byIndex&&byId[0]!==byIndex[0])throw upstream('Conflicting Postman tool fragment correlation.','upstream_tool_fragment_error');const existing=byId||byIndex;const key=existing?.[0]||(chunk.id?`id:${chunk.id}`:chunk.index!==undefined?`index:${chunk.index}`:null);if(!key)throw upstream('Postman tool fragment has no ID or index.','upstream_tool_fragment_error');
+        const current=existing?.[1]||{id:chunk.id||null,index:chunk.index??tools.size,name:null,argsBytes:0,started:false,groupId:null};const upstreamName=chunk.function?.name??chunk.name;if(upstreamName){const original=toolNameMap.get(upstreamName);if(!original)throw upstream('Postman returned an unregistered tool name.','upstream_unregistered_tool');if(current.name&&current.name!==original)throw upstream('Postman tool name changed mid-stream.','upstream_tool_fragment_error');current.name=original;}
+        const args=chunk.function?.arguments??chunk.arguments;let fragment='';if(args!==undefined){if(typeof args==='string')fragment=args;else if(args&&typeof args==='object'&&!current.started)fragment=JSON.stringify(args);else throw upstream('Unsupported Postman tool argument fragment.','upstream_unverified_tool_shape');current.argsBytes+=Buffer.byteLength(fragment);if(current.argsBytes>maxToolArgumentBytes)throw upstream('Tool arguments exceed the configured limit.','upstream_tool_arguments_too_large');}
+        current.groupId=chunk.toolCallGroupId??current.groupId;tools.set(key,current);if(!current.started){if(!current.id||!current.name) { if(fragment) throw upstream('Tool arguments arrived before ID/name.','upstream_tool_fragment_error'); continue; } current.started=true;out.push({type:'tool_call_start',index:current.index,id:current.id,name:current.name,groupId:current.groupId});}if(fragment)out.push({type:'tool_args_delta',index:current.index,id:current.id,arguments:fragment});
+      }return out;
+    },
+    finish(){return [{type:'finish',reason:tools.size?'tool_calls':'stop'}];}
+  };
+}

package/src/postman-request.mjs

@@ -0,0 +1,49 @@
+import { upstreamUrl } from './config.mjs';
+import { invalid } from './errors.mjs';
+import { buildTranscript } from './openai.mjs';
+
+export function catalogMetadata(config) {
+  const metadata = { platform: config.platform ?? 'OPENAI_COMPATIBLE_ADAPTER', excludedTools: [...(config.excludedTools ?? [])] };
+  if (config.nativeToolsHash !== undefined) metadata.nativeToolsHash = config.nativeToolsHash;
+  return metadata;
+}
+
+function clientTools(request, metadata) {
+  const thirdParty = request.tools.length ? { 'openai-client': { tools: request.tools.map(({ originalName, ...tool }) => tool) } } : {};
+  const tools = { excludedTools: [...metadata.excludedTools], thirdParty };
+  if (metadata.nativeToolsHash !== undefined) tools.nativeToolsHash = metadata.nativeToolsHash;
+  return tools;
+}
+
+function envelope(request, config, input) {
+  const metadata = catalogMetadata(config);
+  return {
+    url: upstreamUrl(config),
+    init: {
+      method: 'POST', redirect: 'error',
+      headers: { 'content-type': 'application/json', accept: 'text/event-stream', 'x-access-token': config.upstreamToken, 'x-pstmn-req-service': 'agent-mode-service', 'x-app-version': config.appVersion },
+      body: JSON.stringify({ input, platform: metadata.platform, clientTools: clientTools(request, metadata), mandatoryContext: { workspaceId: config.workspaceId }, devModeOptions: { selectedModel: request.model } }),
+    },
+  };
+}
+
+export function buildPostmanRequest(request, config, continuation = null) {
+  if (config.transportStrategy === 'web_session') throw invalid('web_session transport is not active until its event and terminal parser is implemented.', 'web_session_transport_not_active');
+  if (request.toolResults?.length && !continuation) throw invalid('Tool-result continuation is not correlated.', config.correlationEnabled === false ? 'unsupported_tool_result_continuation' : 'unknown_tool_call');
+  if (continuation) {
+    const { group, orderedResults } = continuation;
+    const input = { chatType: 'TOOL_RESPONSE', query: '', conversationId: group.conversationId, product: 'workspace_v12', useCase: null };
+    if (group.upstreamGroupId) {
+      input.toolCallGroupId = group.upstreamGroupId;
+      input.toolResponses = group.calls.map((call, index) => ({ toolCallId: call.upstreamToolCallId, content: orderedResults[index].content, toolResponseSummary: `Result for ${call.originalName}`, toolResponseStatus: 'SUCCESS' }));
+    } else {
+      if (group.calls.length !== 1) throw invalid('Multiple ungrouped tool calls cannot be continued natively.', 'tool_result_group_mismatch');
+      input.toolCallId = group.calls[0].upstreamToolCallId;
+      input.toolResponse = orderedResults[0].content;
+      input.toolResponseSummary = `Result for ${group.calls[0].originalName}`;
+    }
+    return envelope(request, config, input);
+  }
+  const input = { chatType: 'USER_QUERY', query: JSON.stringify({ format: 'openai-full-history-v1', messages: buildTranscript(request.messages), tool_choice: request.toolChoice }), conversationId: null, product: 'workspace_v12', toolCallGroupId: null, toolResponses: [] };
+  return envelope(request, config, input);
+}

package/src/schema.mjs

@@ -0,0 +1,35 @@
+import { invalid } from './errors.mjs';
+const supported = new Set(['type','properties','required','additionalProperties','patternProperties','items','enum','const','anyOf','oneOf','allOf','description','title','default','minimum','maximum','minLength','maxLength','minItems','maxItems','$schema','$id']);
+export function validateSchemaDefinition(schema, path = '$') {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) throw invalid(`Tool schema at ${path} must be an object.`, 'invalid_tool_schema');
+  for (const key of Object.keys(schema)) if (!supported.has(key)) throw invalid(`Unsupported JSON Schema keyword ${key} at ${path}.`, 'unsupported_tool_schema');
+  if (schema.type !== undefined && !['object','array','string','number','integer','boolean','null'].includes(schema.type)) throw invalid(`Unsupported schema type at ${path}.`, 'unsupported_tool_schema');
+  if (schema.properties !== undefined) { if (!schema.properties || typeof schema.properties !== 'object' || Array.isArray(schema.properties)) throw invalid(`properties at ${path} must be an object.`, 'invalid_tool_schema'); for (const [k,v] of Object.entries(schema.properties)) validateSchemaDefinition(v, `${path}.properties.${k}`); }
+  if (schema.patternProperties !== undefined) { if (!schema.patternProperties || typeof schema.patternProperties !== 'object' || Array.isArray(schema.patternProperties)) throw invalid(`patternProperties at ${path} must be an object.`, 'invalid_tool_schema'); for (const [k,v] of Object.entries(schema.patternProperties)) validateSchemaDefinition(v, `${path}.patternProperties.${k}`); }
+  if (schema.required !== undefined && (!Array.isArray(schema.required) || schema.required.some(k => typeof k !== 'string'))) throw invalid(`required at ${path} must be an array of strings.`, 'invalid_tool_schema');
+  if (schema.additionalProperties !== undefined && typeof schema.additionalProperties !== 'boolean') throw invalid(`additionalProperties at ${path} supports booleans only.`, 'unsupported_tool_schema');
+  if (schema.items !== undefined) validateSchemaDefinition(schema.items, `${path}.items`);
+  if (schema.enum !== undefined && (!Array.isArray(schema.enum) || !schema.enum.length)) throw invalid(`enum at ${path} must be a non-empty array.`, 'invalid_tool_schema');
+  for (const key of ['minimum','maximum']) if (schema[key] !== undefined && (typeof schema[key] !== 'number' || !Number.isFinite(schema[key]))) throw invalid(`${key} at ${path} must be a finite number.`, 'invalid_tool_schema');
+  for (const key of ['minLength','maxLength','minItems','maxItems']) if (schema[key] !== undefined && (!Number.isSafeInteger(schema[key]) || schema[key] < 0)) throw invalid(`${key} at ${path} must be a non-negative integer.`, 'invalid_tool_schema');
+  for (const key of ['anyOf','oneOf','allOf']) if (schema[key] !== undefined) { if (!Array.isArray(schema[key]) || !schema[key].length) throw invalid(`${key} at ${path} must be a non-empty array.`, 'invalid_tool_schema'); schema[key].forEach((v,i)=>validateSchemaDefinition(v,`${path}.${key}[${i}]`)); }
+  return schema;
+}
+function fail(path, message) { throw invalid(`Tool arguments ${path} ${message}.`, 'tool_arguments_schema_mismatch'); }
+export function validateValue(value, schema, path = '$') {
+  if (schema.const !== undefined && JSON.stringify(value) !== JSON.stringify(schema.const)) fail(path, 'does not match const');
+  if (schema.enum && !schema.enum.some(v => JSON.stringify(v) === JSON.stringify(value))) fail(path, 'is not in enum');
+  if (schema.anyOf && !schema.anyOf.some(s => { try { validateValue(value,s,path); return true; } catch { return false; } })) fail(path,'does not match anyOf');
+  if (schema.oneOf && schema.oneOf.filter(s => { try { validateValue(value,s,path); return true; } catch { return false; } }).length !== 1) fail(path,'does not match exactly one oneOf branch');
+  if (schema.allOf) schema.allOf.forEach(s=>validateValue(value,s,path));
+  const type = schema.type;
+  if (type === 'object') { if (!value || typeof value !== 'object' || Array.isArray(value)) fail(path,'must be an object'); const req=schema.required||[]; for(const k of req) if(!(k in value)) fail(`${path}.${k}`,'is required'); if(schema.additionalProperties===false) for(const k of Object.keys(value)) if(!schema.properties?.[k]) fail(`${path}.${k}`,'is not allowed'); for(const [k,v] of Object.entries(value)) if(schema.properties?.[k]) validateValue(v,schema.properties[k],`${path}.${k}`); }
+  else if (type === 'array') { if(!Array.isArray(value)) fail(path,'must be an array'); if(schema.minItems!==undefined&&value.length<schema.minItems) fail(path,'has too few items'); if(schema.maxItems!==undefined&&value.length>schema.maxItems) fail(path,'has too many items'); if(schema.items) value.forEach((v,i)=>validateValue(v,schema.items,`${path}[${i}]`)); }
+  else if (type === 'string') { if(typeof value!=='string') fail(path,'must be a string'); if(schema.minLength!==undefined&&value.length<schema.minLength) fail(path,'is too short'); if(schema.maxLength!==undefined&&value.length>schema.maxLength) fail(path,'is too long'); }
+  else if (type === 'number' && (typeof value!=='number'||!Number.isFinite(value))) fail(path,'must be a finite number');
+  else if (type === 'integer' && !Number.isSafeInteger(value)) fail(path,'must be an integer');
+  else if (type === 'boolean' && typeof value!=='boolean') fail(path,'must be a boolean');
+  else if (type === 'null' && value!==null) fail(path,'must be null');
+  if(typeof value==='number'){ if(schema.minimum!==undefined&&value<schema.minimum) fail(path,'is below minimum'); if(schema.maximum!==undefined&&value>schema.maximum) fail(path,'is above maximum'); }
+  return true;
+}

package/src/server.mjs

@@ -0,0 +1,73 @@
+import { SessionMappingStore } from './session-store.mjs';
+import { handleAdminRequest } from './admin.mjs';
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { authenticate, assertModel, ConcurrencyGate } from './config.mjs';
+import { ProviderError, errorBody, invalid } from './errors.mjs';
+import { normalizeOpenAIRequest } from './openai.mjs';
+import { canonicalEvents } from './transport.mjs';
+import { createResponseState } from './openai-response.mjs';
+import { encodeOpenAIFrame } from './sse.mjs';
+import { CorrelationStore } from './correlation-store.mjs';
+import { catalogMetadata } from './postman-request.mjs';
+import { webSessionCatalogMetadata } from './web-session-request.mjs';
+import { upstreamUrl, webSessionUrl } from './config.mjs';
+async function readJson(req,limit,signal){const chunks=[];let size=0;for await(const chunk of req){signal.throwIfAborted();size+=chunk.length;if(size>limit)throw new ProviderError(413,'Request body exceeds the configured limit.','invalid_request_error','request_too_large');chunks.push(chunk);}let value;try{value=JSON.parse(Buffer.concat(chunks).toString('utf8'));}catch{throw invalid('Request body is not valid JSON.','invalid_json');}return value;}
+const json=(res,status,value,headers={})=>{res.writeHead(status,{'content-type':'application/json; charset=utf-8',...headers});res.end(JSON.stringify(value));};
+export function createProviderServer(config,{fetchImpl=fetch,logger=console,correlationStore=null,sessionStore=null}={}){const sessions=sessionStore||new SessionMappingStore();const gate=new ConcurrencyGate(config.maxConcurrent);const store=correlationStore||new CorrelationStore({pendingTtlMs:config.correlationPendingTtlMs,terminalTtlMs:config.correlationTerminalTtlMs,inflightTtlMs:config.correlationInflightTtlMs,maxGroups:config.correlationMaxGroups,maxCalls:config.correlationMaxCalls,maxBytes:config.correlationMaxBytes});return http.createServer(async(req,res)=>{const requestId=randomUUID();res.setHeader('request-id',requestId);const controller=new AbortController();const timer=setTimeout(()=>controller.abort(new ProviderError(504,'Request timed out.','api_error','request_timeout')),config.timeoutMs);timer.unref();const onClose=()=>{if(!res.writableEnded)controller.abort(new ProviderError(499,'Client disconnected.','api_error','client_disconnected'));};res.on('close',onClose);let leave,claim=null,dispatched=false;
+    try{const url=new URL(req.url,'http://localhost');if(await handleAdminRequest(req,res,config,url.pathname))return;if(url.pathname==='/health'&&req.method==='GET'){json(res,200,{status:'ok',upstream_verified:false,...(config.exposeHealthDetails?{models:config.models.length,active:gate.active,correlations:store.size}:{})});return;}if(url.pathname==='/v1/models'&&req.method==='GET'){authenticate(req.headers.authorization,config.apiKey,config);json(res,200,{object:'list',data:config.models.map(id=>({id,object:'model',created:0,owned_by:'postman-openai-provider'}))});return;}const principal=authenticate(req.headers.authorization,config.apiKey,config);if(url.pathname!=='/v1/chat/completions'||req.method!=='POST')throw new ProviderError(404,'Route not found.','invalid_request_error','not_found');leave=gate.enter();const body=await readJson(req,config.maxBodyBytes,controller.signal);assertModel(body.model,config);const request=normalizeOpenAIRequest(body,config);
+const sessionId = req.headers['x-session-id'] || req.headers['session-id'] || body.user || null;
+const isNewSessionRequest = request.messages.some(m => typeof m.content === 'string' && (m.content.trim() === '/new' || m.content.includes('[reset-session]')));
+if (isNewSessionRequest && sessionId) {
+  sessions.reset(sessionId);
+}
+if (!request.toolResults.length && sessionId && !isNewSessionRequest) {
+  const boundConvoId = sessions.getConversationId(sessionId);
+  if (boundConvoId) {
+    request.establishedConversationId = boundConvoId;
+  }
+}
+const dynamicSubdomain = req.headers['x-postman-subdomain'] || req.headers['x-team-subdomain'] || config.webSessionSubdomain;
+const dynamicWorkspaceId = req.headers['x-postman-workspace-id'] || req.headers['x-workspace-id'] || config.workspaceId;
+const effectiveConfig = (devSubdomain => devSubdomain !== config.webSessionSubdomain || dynamicWorkspaceId !== config.workspaceId ? { ...config, webSessionSubdomain: devSubdomain, workspaceId: dynamicWorkspaceId } : config)(dynamicSubdomain);
+const transportOrigin=effectiveConfig.transportStrategy==='web_session'?webSessionUrl(effectiveConfig).origin:upstreamUrl(effectiveConfig).origin;const effectiveCatalogMetadata=effectiveConfig.transportStrategy==='web_session'?webSessionCatalogMetadata(request,effectiveConfig):catalogMetadata(effectiveConfig);
+      const traceId = typeof req.headers['x-trace-id'] === 'string' && /^[A-Za-z0-9._-]{1,128}$/.test(req.headers['x-trace-id']) ? req.headers['x-trace-id'] : null;
+      if (traceId) logger.info?.({ event: 'request_trace', traceId, model: request.model, sessionId: sessionId || null, transport: effectiveConfig.transportStrategy, origin: transportOrigin });
+      if(request.toolResults.length){
+        if(config.correlationEnabled===false)throw invalid('Tool-result continuation is disabled.','unsupported_tool_result_continuation');
+        let group = null;
+        try {
+          group = store.resolve(principal.principalId, request.toolResults.map(result => result.toolCallId));
+          claim = store.claim({principalId:principal.principalId,results:request.toolResults,workspaceId:config.workspaceId,model:request.model,transportStrategy:config.transportStrategy,transportOrigin,transcript:request.transcriptPrefix,toolsBinding:request.toolsBinding,catalogMetadata:effectiveCatalogMetadata});
+          // Keep the complete client-declared tool registry on continuation turns.
+          // Restricting the maps to the calls from the immediately preceding
+          // group makes a valid sequential next-tool call look undeclared.
+          for (const call of group.calls) {
+            if (!request.toolNameMap.has(`openai__${call.originalName}`)) throw invalid('Tool continuation references a tool outside the current declaration.', 'continuation_tool_binding_mismatch');
+          }
+        } catch(err) {
+          // Fallback if correlation was lost during restart
+          const boundConvoId = sessions.getConversationId(sessionId);
+          if (boundConvoId) {
+            claim = {
+              conversationId: boundConvoId,
+              orderedResults: request.toolResults,
+              syntheticToolCallId: request.toolResults[0]?.toolCallId || 'call_01',
+              group: {
+                conversationId: boundConvoId,
+                calls: request.toolResults.map(tr => ({
+                  upstreamToolCallId: tr.toolCallId,
+                  originalName: 'tool_response'
+                }))
+              }
+            };
+          } else {
+            throw err;
+          }
+        }
+      }
+      const state=createResponseState(request);const events=[];for await(const event of canonicalEvents(request,effectiveConfig,{fetchImpl,signal:controller.signal,continuation:claim,onDispatched:()=>{dispatched=true;}})){state.apply(event);events.push(event);if(event.type==='response_start'&&event.conversationId&&sessionId){sessions.setConversationId(sessionId,event.conversationId);}if(request.stream&&!state.hasTools()&&event.type!=='tool_call_start'&&event.type!=='tool_args_delta'){if(!res.headersSent)res.writeHead(200,{'content-type':'text/event-stream; charset=utf-8','cache-control':'no-cache, no-transform','x-accel-buffering':'no'});const chunk=state.chunk(event);if(chunk)res.write(encodeOpenAIFrame(chunk));}}
+      const assistant=state.message();if(state.hasTools()){const transcript=[...request.messages,{...assistant,content:assistant.content??''}];state.admit(store,{principalId:principal.principalId,workspaceId:config.workspaceId,model:request.model,transportStrategy:config.transportStrategy,transportOrigin,transcript,toolsBinding:request.toolsBinding,catalogMetadata:effectiveCatalogMetadata});}
+      if(request.stream){if(!res.headersSent)res.writeHead(200,{'content-type':'text/event-stream; charset=utf-8','cache-control':'no-cache, no-transform','x-accel-buffering':'no'});if(state.hasTools()){res.write(encodeOpenAIFrame({id:state.id,object:'chat.completion.chunk',created:state.created,model:request.model,choices:[{index:0,delta:{role:'assistant',content:''},finish_reason:null}]}));for(const chunk of state.toolChunks())res.write(encodeOpenAIFrame(chunk));const finish=events.findLast(event=>event.type==='finish');if(finish)res.write(encodeOpenAIFrame(state.chunk(finish)));}res.end(encodeOpenAIFrame('[DONE]'));if(claim)store.complete(claim.group);}
+      else{const result=state.result();if(claim)store.complete(claim.group,result);json(res,200,result);}
+    }catch(cause){if(claim?.group?.state==='INFLIGHT'){if(cause?.preSend===true&&!dispatched)store.releasePreSend(claim.group);else store.uncertain(claim.group);}const error=controller.signal.aborted&&controller.signal.reason instanceof ProviderError?controller.signal.reason:cause instanceof ProviderError?cause:new ProviderError(500,'The provider could not complete the request.','api_error','internal_error');logger.error?.(JSON.stringify({event:'request_error',request_id:requestId,status:error.status,code:error.code,...(error.upstreamDetail?{upstream:error.upstreamDetail}:{})}));if(!res.destroyed){if(res.headersSent){res.end(encodeOpenAIFrame({error:errorBody(error,requestId).error}));}else{const headers=error.retryAfter?{'retry-after':String(error.retryAfter)}:{};json(res,error.status,errorBody(error,requestId),headers);}}}finally{clearTimeout(timer);res.off('close',onClose);leave?.();}});}

package/src/session-store.mjs

@@ -0,0 +1,48 @@
+
+export class SessionMappingStore {
+  #conversations = new Map();
+  #expiresAt = new Map();
+
+  constructor({ ttlMs = 24 * 60 * 60 * 1000, maxSessions = 1000 } = {}) {
+    this.ttlMs = ttlMs;
+    this.maxSessions = maxSessions;
+  }
+
+
+  getConversationId(sessionId) {
+    if (!sessionId) return null;
+    this.sweep();
+    return this.#conversations.get(sessionId) || null;
+  }
+
+
+  setConversationId(sessionId, conversationId) {
+    if (!sessionId || !conversationId) return;
+    this.sweep();
+    if (this.#conversations.size >= this.maxSessions) {
+      const oldest = this.#conversations.keys().next().value;
+      if (oldest) { this.#conversations.delete(oldest); this.#expiresAt.delete(oldest); }
+    }
+    this.#conversations.set(sessionId, conversationId);
+    this.#expiresAt.set(sessionId, Date.now() + this.ttlMs);
+  }
+
+
+  reset(sessionId) {
+    if (!sessionId) return;
+    this.#conversations.delete(sessionId);
+    this.#expiresAt.delete(sessionId);
+  }
+
+
+  sweep(now = Date.now()) {
+    for (const [sessionId, expires] of this.#expiresAt.entries()) {
+      if (now >= expires) {
+        this.#conversations.delete(sessionId);
+        this.#expiresAt.delete(sessionId);
+      }
+    }
+  }
+
+  get size() { return this.#conversations.size; }
+}

package/src/sse.mjs

@@ -0,0 +1,13 @@
+import { upstream } from './errors.mjs';
+export async function* abortableBytes(body, signal) {
+  if(!body) throw upstream('Postman gateway returned no response body.','upstream_empty_body');
+  const reader=body.getReader(); const cancel=()=>void reader.cancel(signal.reason).catch(()=>{}); signal.addEventListener('abort',cancel,{once:true});
+  try{while(true){signal.throwIfAborted();const {done,value}=await reader.read();signal.throwIfAborted();if(done)return;yield value;}}finally{signal.removeEventListener('abort',cancel);await reader.cancel().catch(()=>{});reader.releaseLock();}
+}
+export async function* parseSSE(source,maxEventBytes) {
+  const decoder=new TextDecoder('utf-8',{fatal:true}); let buffer='',event='',data=[],size=0;
+  const line=value=>{if(value===''){const frame=data.length?{event:event||'message',data:data.join('\n')}:null;event='';data=[];size=0;return frame;}if(value.startsWith(':'))return null;const colon=value.indexOf(':');const key=colon<0?value:value.slice(0,colon);const content=colon<0?'':value.slice(colon+1).replace(/^ /,'');if(key==='data'){data.push(content);size+=Buffer.byteLength(content);if(size>maxEventBytes)throw upstream('Upstream SSE event exceeds the configured limit.','upstream_event_too_large');}if(key==='event')event=content;return null;};
+  try{for await(const bytes of source){buffer+=typeof bytes==='string'?bytes:decoder.decode(bytes,{stream:true});if(Buffer.byteLength(buffer)+size>maxEventBytes*2)throw upstream('Upstream SSE parser buffer exceeds the configured limit.','upstream_event_too_large');let match;while((match=/\r\n|\r|\n/.exec(buffer))){if(match[0]==='\r'&&match.index===buffer.length-1)break;const frame=line(buffer.slice(0,match.index));buffer=buffer.slice(match.index+match[0].length);if(frame)yield frame;}}buffer+=decoder.decode();}catch(error){if(error?.code)throw error;throw upstream('Postman gateway sent invalid UTF-8 SSE.','upstream_invalid_utf8');}
+  if(buffer.endsWith('\r'))buffer=buffer.slice(0,-1);if(buffer){const frame=line(buffer);if(frame)yield frame;}const frame=line('');if(frame)yield frame;
+}
+export const encodeOpenAIFrame=value=>`data: ${typeof value==='string'?value:JSON.stringify(value)}\n\n`;

package/src/transport.mjs

@@ -0,0 +1,90 @@
+import { upstream } from './errors.mjs';
+import { abortableBytes, parseSSE } from './sse.mjs';
+import { buildPostmanRequest } from './postman-request.mjs';
+import { createRawEventAdapter } from './postman-events.mjs';
+import { buildWebSessionRequest } from './web-session-request.mjs';
+import { createWebSessionEventParser } from './web-session-events.mjs';
+
+async function fetchUpstream(url, init, { fetchImpl, signal, onDispatched }) {
+  try {
+    const response = await fetchImpl(url, { ...init, signal });
+    onDispatched?.();
+    return response;
+  } catch (error) {
+    if (error?.preSend === true) error.preSend = true;
+    else error.dispatchUncertain = true;
+    throw error;
+  }
+}
+
+async function assertEventStream(response, label) {
+  if (!response.ok) {
+    await response.body?.cancel().catch(() => {});
+    throw upstream(`${label} returned HTTP ${response.status}.`, 'upstream_http_error', response.status, { retryAfter: response.headers.get('retry-after') });
+  }
+  if (!response.headers.get('content-type')?.toLowerCase().includes('text/event-stream')) {
+    await response.body?.cancel().catch(() => {});
+    throw upstream(`${label} did not return text/event-stream.`, 'upstream_content_type_error');
+  }
+}
+
+async function* accessTokenEvents(request, config, options) {
+  const { url, init } = buildPostmanRequest(request, config, options.continuation);
+  const response = await fetchUpstream(url, init, options);
+  await assertEventStream(response, 'Postman gateway');
+  const adapter = createRawEventAdapter({ toolNameMap: request.toolNameMap, maxToolArgumentBytes: config.maxToolArgumentBytes, maxOutputBytes: config.maxOutputBytes });
+  let done = false;
+  for await (const frame of parseSSE(abortableBytes(response.body, options.signal), config.maxEventBytes)) {
+    options.signal.throwIfAborted();
+    if (frame.data.trim() === '[DONE]') { done = true; break; }
+    for (const event of adapter.adapt(frame)) yield event;
+  }
+  if (!done) throw upstream('Postman stream disconnected before [DONE].', 'upstream_incomplete_stream');
+  for (const event of adapter.finish()) yield event;
+}
+
+async function* webSessionEvents(request, config, options) {
+  const { url, init } = buildWebSessionRequest(request, config, options.continuation);
+  const response = await fetchUpstream(url, init, options);
+  await assertEventStream(response, 'Postman web-session gateway');
+  const parser = createWebSessionEventParser({
+    maxEventBytes: config.maxEventBytes,
+    maxOutputBytes: config.maxOutputBytes,
+    requestedModel: request.model,
+    selectedUpstreamModel: config.selectedUpstreamModel,
+    allowedObservedModels: config.webSessionObservedModels,
+    toolNameMap: request.toolNameMap,
+    maxToolArgumentBytes: config.maxToolArgumentBytes,
+  });
+  for await (const bytes of abortableBytes(response.body, options.signal)) {
+    options.signal.throwIfAborted();
+    parser.feed(bytes);
+  }
+  const result = parser.end();
+  if (!result.successful) {
+    if (result.error) {
+      const error = upstream(result.error.message, result.error.code, result.error.status, { cause: result.error });
+      if (typeof result.error.observedModel === 'string') error.observedModel = result.error.observedModel;
+      if (typeof result.error.observedModelField === 'string') error.observedModelField = result.error.observedModelField;
+      throw error;
+    }
+    throw upstream('Postman web-session did not prove successful completion.', 'upstream_incomplete_stream');
+  }
+  yield { type: 'response_start', conversationId: result.observations.conversationId };
+  if (result.text) yield { type: 'text_delta', text: result.text };
+  for (const call of result.toolCalls) {
+    yield { type: 'tool_call_start', index: call.index, id: call.upstreamId, name: call.originalName, groupId: call.groupId };
+    if (call.arguments) yield { type: 'tool_args_delta', index: call.index, arguments: call.arguments };
+  }
+  if (result.observations.usage) yield { type: 'usage', usage: result.observations.usage, estimated: false };
+  yield { type: 'finish', reason: result.toolCalls.length ? 'tool_calls' : 'stop' };
+}
+
+export async function* canonicalEvents(request, config, options = {}) {
+  const resolved = { fetchImpl: fetch, signal: undefined, continuation: null, onDispatched: null, ...options };
+  if (config.transportStrategy === 'web_session') {
+    yield* webSessionEvents(request, config, resolved);
+    return;
+  }
+  yield* accessTokenEvents(request, config, resolved);
+}