aki-pro-max 2.3.3

package/src/web-session-events.mjs

@@ -0,0 +1,358 @@
+import { upstream } from './errors.mjs';
+
+const PROGRESS_EVENTS = new Set([
+  'thinkingChunk',
+  'thinkingComplete',
+  'planningChunk',
+  'progressUpdate',
+  'info',
+  'ping',
+  'todoChunk',
+  'streamingFormat',
+]);
+const UNSUPPORTED_EVENTS = new Map([
+  ['loopApprovalChunk', ['Postman web-session text profile does not support loop approval.', 'upstream_web_session_loop_approval_unsupported']],
+]);
+const object = value => value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+const stableError = (message, code, status = 502) => upstream(message, code, status);
+const errorView = error => error ? Object.freeze({ status: error.status, code: error.code, message: error.message }) : null;
+const exactStrings = values => {
+  if (values === undefined) return Object.freeze([]);
+  if (!Array.isArray(values) || values.some(value => typeof value !== 'string' || !value || Buffer.byteLength(value, 'utf8') > 128)) throw new TypeError('allowedObservedModels must contain bounded non-empty strings.');
+  return Object.freeze([...new Set(values)]);
+};
+const boundedIdentity = (value, field) => {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== 'string' || !value || Buffer.byteLength(value, 'utf8') > 128) throw new TypeError(`${field} must be a bounded non-empty string when provided.`);
+  return value;
+};
+const positiveBound = (value, field, fallback) => {
+  const number = value ?? fallback;
+  if (!Number.isSafeInteger(number) || number < 1) throw new TypeError(`${field} must be a positive safe integer.`);
+  return number;
+};
+const eventName = (event, frameEvent) => {
+  if (typeof event.eventType === 'string' && event.eventType) return event.eventType;
+  if (typeof event.type === 'string' && event.type) return event.type;
+  return frameEvent || 'message';
+};
+const firstString = values => values.find(value => typeof value === 'string' && value.length) ?? null;
+const upstreamFailureDetail = event => {
+  const data = object(event?.data);
+  const nested = object(data?.error) || object(event?.error);
+  const code = firstString([nested?.code, data?.code, event?.code, nested?.type, data?.type]);
+  const requestId = firstString([nested?.requestId, nested?.request_id, data?.requestId, data?.request_id, event?.requestId, event?.request_id]);
+  const message = firstString([nested?.message, typeof data?.error === 'string' ? data.error : null, typeof event?.error === 'string' ? event.error : null, data?.message, event?.message]);
+  const bounded = value => typeof value === 'string' ? value.slice(0, 200).replace(/[\r\n]+/g, ' ') : null;
+  const safeMessage = bounded(message)?.replace(/(?:bearer|authorization|api[_-]?key|token|cookie|secret)[^,;]*/gi, '[redacted]') ?? null;
+  return Object.freeze({ code: bounded(code), requestId: bounded(requestId), message: safeMessage });
+};
+const firstModelField = entries => {
+  const found = entries.find(([, value]) => typeof value === 'string' && value.length);
+  return found ? { fieldPath: found[0], value: found[1] } : null;
+};
+const observedModelFor = event => firstModelField([
+  ['metadata.model', event?.metadata?.model],
+  ['metadata.modelId', event?.metadata?.modelId],
+  ['metadata.selectedModel', event?.metadata?.selectedModel],
+  ['data.metadata.model', event?.data?.metadata?.model],
+  ['data.metadata.modelId', event?.data?.metadata?.modelId],
+  ['data.metadata.selectedModel', event?.data?.metadata?.selectedModel],
+  ['data.model', event?.data?.model],
+  ['data.modelId', event?.data?.modelId],
+  ['data.selectedModel', event?.data?.selectedModel],
+]);
+const nonNegativeSafe = value => Number.isSafeInteger(value) && value >= 0;
+
+export function createWebSessionEventParser(options = {}) {
+  const maxEventBytes = positiveBound(options.maxEventBytes, 'maxEventBytes', 1_048_576);
+  const maxOutputBytes = positiveBound(options.maxOutputBytes, 'maxOutputBytes', 4_194_304);
+  const maxObservationBytes = positiveBound(options.maxObservationBytes, 'maxObservationBytes', Math.min(maxEventBytes, 4096));
+  const maxEvents = positiveBound(options.maxEvents, 'maxEvents', 4096);
+  const requestedModel = boundedIdentity(options.requestedModel, 'requestedModel');
+  const selectedUpstreamModel = boundedIdentity(options.selectedUpstreamModel, 'selectedUpstreamModel');
+  const allowedObservedModels = exactStrings(options.allowedObservedModels);
+  const toolNameMap = options.toolNameMap instanceof Map ? options.toolNameMap : new Map();
+  const maxToolArgumentBytes = positiveBound(options.maxToolArgumentBytes, 'maxToolArgumentBytes', 1_048_576);
+  const decoder = new TextDecoder('utf-8', { fatal: true });
+
+  let buffer = '';
+  let frameEvent = '';
+  let frameData = [];
+  let frameBytes = 0;
+  let text = '';
+  let outputBytes = 0;
+  let toolArgumentBytes = 0;
+  const toolCalls = new Map();
+  let conversationId = null;
+  let usage = null;
+  let observedUpstreamModel = null;
+  let modelVerification = 'unobserved';
+  let explicitTerminal = null;
+  let transportEof = false;
+  let parserBufferComplete = false;
+  let sawValidEvent = false;
+  let sawMeaningfulOutput = false;
+  let eventCount = 0;
+  let ended = false;
+  let terminalError = null;
+  let outcome = 'open';
+  const eventTypes = new Set();
+
+  const fail = error => {
+    terminalError ||= error;
+    outcome = 'failed';
+    throw terminalError;
+  };
+  const addFrameBytes = value => {
+    frameBytes += Buffer.byteLength(value, 'utf8') + 1;
+    if (frameBytes > maxEventBytes) fail(stableError('Upstream SSE event exceeds the configured limit.', 'upstream_event_too_large'));
+  };
+  const boundedObservation = (value, code, message) => {
+    if (typeof value !== 'string' || !value || Buffer.byteLength(value, 'utf8') > maxObservationBytes) fail(stableError(message, code));
+    return value;
+  };
+  const observeModel = event => {
+    const observation = observedModelFor(event);
+    if (observation === null) return;
+    const value = observation.value.trim();
+    boundedObservation(value, 'upstream_unverified_event_shape', 'Postman web-session model observation has an invalid shape.');
+    if (observedUpstreamModel && observedUpstreamModel !== value) {
+      const err = stableError('Postman web-session model observation changed mid-stream.', 'upstream_model_mismatch');
+      err.observedModel = value; err.observedModelField = observation.fieldPath;
+      fail(err);
+    }
+    observedUpstreamModel = value;
+    if (!allowedObservedModels.length) {
+      modelVerification = 'unverified';
+      return;
+    }
+    if (!allowedObservedModels.includes(value)) {
+      modelVerification = 'mismatched';
+      const err = stableError('Postman web-session observed model did not match the configured mapping.', 'upstream_model_mismatch');
+      err.observedModel = value; err.observedModelField = observation.fieldPath;
+      fail(err);
+    }
+    modelVerification = 'matched';
+  };
+  const recordEvent = name => {
+    eventCount++;
+    if (eventCount > maxEvents) fail(stableError('Postman web-session emitted too many events.', 'upstream_event_count_exceeded'));
+    eventTypes.add(name);
+  };
+  const handleUsage = data => {
+    const value = object(data);
+    if (!value) fail(stableError('Postman web-session usage event has an unverified shape.', 'upstream_unverified_event_shape'));
+    if (typeof value.usageState === 'string') {
+      const state = value.usageState.toUpperCase();
+      if (state === 'BLOCKED' || state === 'EXCEEDED' || state === 'UNAVAILABLE') fail(stableError('Postman AI credit access is unavailable.', 'upstream_credit_blocked', 400));
+      if (state !== 'AVAILABLE') fail(stableError('Postman gateway reported an unknown credit state.', 'upstream_unknown_credit_state'));
+    }
+    const input = value.inputTokens ?? value.input_tokens ?? value.promptTokens ?? value.prompt_tokens ?? 0;
+    const output = value.outputTokens ?? value.output_tokens ?? value.completionTokens ?? value.completion_tokens ?? 0;
+    const total = value.totalTokens ?? value.total_tokens ?? (input + output);
+    if (![input, output, total].every(nonNegativeSafe) || total < input || total < output) fail(stableError('Postman web-session usage event has invalid token counts.', 'upstream_unverified_event_shape'));
+    usage = Object.freeze({ prompt_tokens: input, completion_tokens: output, total_tokens: total, estimated: false });
+  };
+  const toolEntries = data => {
+    if (!object(data)) fail(stableError('Postman web-session toolCallChunk has an unverified shape.', 'upstream_unverified_event_shape'));
+    if (Array.isArray(data.toolCalls)) {
+      if (!data.toolCalls.length || data.toolCalls.some(value => !object(value))) fail(stableError('Postman web-session toolCallChunk has an invalid toolCalls array.', 'upstream_unverified_event_shape'));
+      return data.toolCalls.map((value, position) => ({ value, position, container: data }));
+    }
+    return [{ value: data, position: 0, container: data }];
+  };
+  const boundedToolIdentity = (value, field) => boundedObservation(value, 'upstream_tool_fragment_error', `Postman web-session tool call is missing a bounded ${field}.`);
+  const handleToolChunk = data => {
+    for (const { value, position, container } of toolEntries(data)) {
+      const explicitIndex = value.index ?? value.toolCallIndex ?? container.index ?? container.toolCallIndex;
+      if (explicitIndex !== undefined && (!Number.isSafeInteger(explicitIndex) || explicitIndex < 0)) fail(stableError('Postman web-session tool call index is invalid.', 'upstream_tool_fragment_error'));
+      const upstreamId = firstString([value.id, value.callId, value.toolCallId, value.call_id, value.tool_call_id, container.id, container.callId, container.toolCallId]);
+      const key = upstreamId ? `id:${upstreamId}` : explicitIndex !== undefined ? `index:${explicitIndex}` : null;
+      if (!key) fail(stableError('Postman web-session tool fragment is missing an ID and index.', 'upstream_tool_fragment_error'));
+      let call = toolCalls.get(key);
+      const sourceName = firstString([value.function?.name, value.name, value.tool?.name, container.function?.name, container.name]);
+      const groupId = firstString([value.toolCallGroupId, value.groupId, value.tool_call_group_id, value.group_id, container.toolCallGroupId, container.groupId, container.tool_call_group_id, container.group_id]);
+      if (!call) {
+        if (!upstreamId) fail(stableError('Postman web-session first tool fragment is missing a bounded ID.', 'upstream_tool_fragment_error'));
+        if (!sourceName) fail(stableError('Postman web-session first tool fragment is missing a bounded name.', 'upstream_tool_fragment_error'));
+        const originalName = toolNameMap.get(boundedToolIdentity(sourceName, 'name'));
+        if (!originalName) fail(stableError('Postman web-session returned an undeclared tool.', 'upstream_unregistered_tool'));
+        call = { index: explicitIndex ?? position, upstreamId: boundedToolIdentity(upstreamId, 'ID'), sourceName, originalName, groupId: groupId ? boundedToolIdentity(groupId, 'group ID') : null, arguments: '' };
+        if ([...toolCalls.values()].some(existing => existing.index === call.index || existing.upstreamId === call.upstreamId)) fail(stableError('Postman web-session tool fragments collide.', 'upstream_tool_fragment_error'));
+        toolCalls.set(key, call);
+      } else {
+        if (upstreamId && upstreamId !== call.upstreamId) fail(stableError('Postman web-session tool call ID changed mid-stream.', 'upstream_tool_fragment_error'));
+        if (sourceName && sourceName !== call.sourceName) fail(stableError('Postman web-session tool call name changed mid-stream.', 'upstream_tool_fragment_error'));
+        if (groupId && groupId !== call.groupId) fail(stableError('Postman web-session tool group changed mid-stream.', 'upstream_tool_fragment_error'));
+      }
+      const rawArguments = value.function?.arguments ?? value.arguments ?? value.input ?? value.input_json;
+      if (rawArguments !== undefined) {
+        const fragment = typeof rawArguments === 'string' ? rawArguments : JSON.stringify(rawArguments);
+        if (typeof fragment !== 'string') fail(stableError('Postman web-session tool arguments have an invalid shape.', 'upstream_tool_fragment_error'));
+        toolArgumentBytes += Buffer.byteLength(fragment, 'utf8');
+        if (toolArgumentBytes > maxToolArgumentBytes) fail(stableError('Postman web-session tool arguments exceed the configured limit.', 'upstream_tool_arguments_too_large'));
+        call.arguments += fragment;
+      }
+    }
+    sawMeaningfulOutput = true;
+  };
+  const handleEvent = (event, name) => {
+    observeModel(event);
+    recordEvent(name);
+    const data = event.data;
+    const observedConversationId = firstString(name === 'conversation'
+      ? [data?.id, data?.conversationId, data?.conversation_id, data?.conversation?.id, data?.conversation?.conversationId]
+      : [event?.conversationId, event?.conversation_id, event?.metadata?.conversationId, event?.metadata?.conversation_id, data?.conversationId, data?.conversation_id, data?.conversation?.id, data?.conversation?.conversationId, data?.metadata?.conversationId, data?.metadata?.conversation_id]);
+    if (observedConversationId) conversationId = boundedObservation(observedConversationId, 'upstream_invalid_conversation', 'Postman web-session conversation ID is invalid.');
+    if (name === 'conversation') {
+      if (!conversationId) fail(stableError('Postman web-session conversation event is missing a bounded ID.', 'upstream_invalid_conversation'));
+      return;
+    }
+    if (name === 'textChunk') {
+      if (typeof data?.textContent !== 'string') fail(stableError('Postman web-session textChunk has an unverified shape.', 'upstream_unverified_event_shape'));
+      outputBytes += Buffer.byteLength(data.textContent, 'utf8');
+      if (outputBytes > maxOutputBytes) fail(stableError('Upstream output exceeds the configured limit.', 'upstream_output_too_large'));
+      text += data.textContent;
+      if (data.textContent.length) sawMeaningfulOutput = true;
+      return;
+    }
+    if (name === 'usage') return handleUsage(data);
+    if (name === 'toolCallChunk') return handleToolChunk(data);
+    if (PROGRESS_EVENTS.has(name)) return;
+    const unsupported = UNSUPPORTED_EVENTS.get(name);
+    if (unsupported) fail(stableError(unsupported[0], unsupported[1], 400));
+    if (name === 'failure' || name === 'error' || /fail|error/i.test(name) || event.result === 'failure' || event.error || data?.error) {
+      const detail = upstreamFailureDetail(event);
+      const error = stableError('Postman web-session reported an upstream failure.', 'upstream_gateway_failure');
+      error.upstreamDetail = detail;
+      fail(error);
+    }
+    fail(stableError('Postman web-session emitted an unverified event type.', 'upstream_unverified_event_shape'));
+  };
+  const dispatch = () => {
+    if (!frameData.length) {
+      frameEvent = '';
+      frameBytes = 0;
+      return;
+    }
+    const payload = frameData.join('\n');
+    const outerEvent = frameEvent || 'message';
+    frameEvent = '';
+    frameData = [];
+    frameBytes = 0;
+    if (explicitTerminal) fail(stableError('Postman web-session sent data after its terminal marker.', 'upstream_data_after_terminal'));
+    if (payload === '[DONE]') {
+      if (outerEvent !== 'message') fail(stableError('Postman web-session terminal marker used an invalid event type.', 'upstream_invalid_terminal'));
+      explicitTerminal = 'done';
+      return;
+    }
+    let event;
+    try { event = JSON.parse(payload); } catch { fail(stableError('Postman web-session sent malformed SSE JSON.', 'upstream_invalid_json')); }
+    if (!object(event)) fail(stableError('Postman web-session sent an invalid SSE event.', 'upstream_invalid_event'));
+    sawValidEvent = true;
+    handleEvent(event, eventName(event, frameEvent || (outerEvent === 'message' ? '' : outerEvent)));
+  };
+  const line = value => {
+    if (explicitTerminal && value !== '') fail(stableError('Postman web-session sent data after its terminal marker.', 'upstream_data_after_terminal'));
+    if (value === '') return dispatch();
+    addFrameBytes(value);
+    if (value.startsWith(':')) return;
+    const colon = value.indexOf(':');
+    const field = colon < 0 ? value : value.slice(0, colon);
+    const content = colon < 0 ? '' : value.slice(colon + 1).replace(/^ /, '');
+    if (field === 'data') frameData.push(content);
+    else if (field === 'event') frameEvent = content;
+  };
+  const processLines = final => {
+    while (buffer.length) {
+      let index = -1;
+      let width = 0;
+      for (let i = 0; i < buffer.length; i++) {
+        if (buffer[i] === '\n') { index = i; width = 1; break; }
+        if (buffer[i] === '\r') {
+          if (i === buffer.length - 1 && !final) return;
+          index = i;
+          width = buffer[i + 1] === '\n' ? 2 : 1;
+          break;
+        }
+      }
+      if (index < 0) return;
+      const value = buffer.slice(0, index);
+      buffer = buffer.slice(index + width);
+      line(value);
+    }
+  };
+  const snapshot = () => Object.freeze({
+    outcome,
+    successful: outcome === 'complete_explicit',
+    text,
+    observations: Object.freeze({
+      requestedModel,
+      selectedUpstreamModel,
+      observedUpstreamModel,
+      modelVerification,
+      conversationId,
+      usage,
+      eventTypes: Object.freeze([...eventTypes]),
+      eventCount,
+      sawValidEvent,
+      sawMeaningfulOutput,
+      explicitTerminal,
+      transportEof,
+      parserBufferComplete,
+    }),
+    toolCalls: Object.freeze([...toolCalls.values()].sort((a,b)=>a.index-b.index).map(value => Object.freeze({ ...value }))),
+    error: errorView(terminalError),
+  });
+
+  return Object.freeze({
+    feed(chunk) {
+      if (ended) throw new TypeError('Cannot feed a web-session parser after end().');
+      if (terminalError) throw terminalError;
+      if (!(chunk instanceof Uint8Array)) throw new TypeError('Web-session parser chunks must be Uint8Array values.');
+      try {
+        buffer += decoder.decode(chunk, { stream: true });
+      } catch {
+        fail(stableError('Postman web-session sent invalid UTF-8 SSE.', 'upstream_invalid_utf8'));
+      }
+      if (Buffer.byteLength(buffer, 'utf8') + frameBytes > maxEventBytes * 2) fail(stableError('Upstream SSE parser buffer exceeds the configured limit.', 'upstream_event_too_large'));
+      processLines(false);
+      return snapshot();
+    },
+    end() {
+      if (ended) return snapshot();
+      ended = true;
+      transportEof = true;
+      if (terminalError) return snapshot();
+      try {
+        buffer += decoder.decode();
+      } catch {
+        terminalError = stableError('Postman web-session ended with incomplete or invalid UTF-8.', 'upstream_invalid_utf8');
+        outcome = 'incomplete_truncated';
+        return snapshot();
+      }
+      try { processLines(true); } catch (error) { return snapshot(); }
+      const partialLine = buffer.length > 0;
+      const partialFrame = frameData.length > 0 || frameEvent.length > 0;
+      parserBufferComplete = !partialLine && !partialFrame;
+      if (terminalError) return snapshot();
+      if (explicitTerminal && !parserBufferComplete) {
+        outcome = 'failed';
+        terminalError = stableError('Postman web-session sent data after its terminal marker.', 'upstream_data_after_terminal');
+      } else if (explicitTerminal) outcome = 'complete_explicit';
+      else if (!parserBufferComplete) {
+        outcome = 'incomplete_truncated';
+        terminalError = stableError('Postman web-session ended with a partial SSE frame.', 'upstream_incomplete_stream');
+      } else if (sawMeaningfulOutput) {
+        outcome = 'ambiguous_eof';
+        terminalError = stableError('Postman web-session ended without proven terminal evidence.', 'upstream_completion_ambiguous');
+      } else {
+        outcome = 'incomplete_empty';
+        terminalError = stableError('Postman web-session ended without meaningful output or terminal evidence.', 'upstream_empty_stream');
+      }
+      return snapshot();
+    },
+    snapshot,
+  });
+}

package/src/web-session-request.mjs

@@ -0,0 +1,280 @@
+
+export const POSTMAN_MODEL_MAP = Object.freeze({
+  'gpt-5.6-sol': 'GPT_56_SOL',
+  'gpt-5.6-sol-thinking': 'GPT_56_SOL',
+  'gpt-5.6-terra': 'GPT_56_TERRA',
+  'gpt-5.6-terra-thinking': 'GPT_56_TERRA',
+  'claude-opus-4-8': 'CLAUDE_OPUS_48_BEDROCK',
+  'claude-opus-4-8-thinking': 'CLAUDE_OPUS_48_BEDROCK',
+  'claude-opus-4-7': 'CLAUDE_OPUS_47_BEDROCK',
+  'claude-opus-4-7-thinking': 'CLAUDE_OPUS_47_BEDROCK',
+});
+
+export function resolveUpstreamModel(model, fallback) {
+  if (typeof model !== 'string') return fallback;
+  const key = model.trim().toLowerCase();
+  return POSTMAN_MODEL_MAP[key] || fallback;
+}
+
+export function isThinkingModel(model) {
+  return typeof model === 'string' && model.trim().toLowerCase().endsWith('-thinking');
+}
+
+import { webSessionUrl } from './config.mjs';
+import { ProviderError, invalid } from './errors.mjs';
+import { buildTranscript } from './openai.mjs';
+
+const USER_AGENT = 'postman-openai-provider/0.1.0 web-session-offline-builder';
+
+function assertRequest(request) {
+  if (!request || typeof request !== 'object') throw invalid('Normalized request is required.', 'invalid_web_session_request');
+  if (!Array.isArray(request.messages) || !request.messages.length) throw invalid('Web-session profile requires message history.', 'invalid_messages');
+  if (request.toolChoice && typeof request.toolChoice === 'object') throw invalid('Web-session profile does not support a named tool_choice.', 'unsupported_web_session_tool_choice');
+  if (!['none', 'auto', 'required'].includes(request.toolChoice)) throw invalid('Web-session profile received an unsupported tool_choice.', 'unsupported_web_session_tool_choice');
+}
+
+function thirdPartyTools(request) {
+  if (!request.tools?.length) return undefined;
+  return {
+    'proxy-tools': {
+      tools: request.tools.map(tool => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters,
+      })),
+    },
+  };
+}
+
+function clientTools(request, config) {
+  const thirdParty = thirdPartyTools(request);
+  if (!thirdParty) return { native: [] };
+  // Keep the legacy direct-tool envelope until current Postman metadata is
+  // discovered from the authenticated client. A bundled/stale native hash can
+  // make upstream store the call under a contract the continuation cannot use.
+  if (config.nativeToolsHash && config.webSessionMetadataSource === 'discovered') {
+    return { nativeToolsHash: config.nativeToolsHash, excludedTools: config.excludedTools || [], thirdParty };
+  }
+  return { native: [], thirdParty };
+}
+
+function clientKBTerms(config) {
+  if (config.nativeTermsHash && config.webSessionMetadataSource === 'discovered') return { nativeTermsHash: config.nativeTermsHash, excludedKBTerms: config.excludedKBTerms || [] };
+  return { native: [] };
+}
+
+function devModeOptions(request, config) {
+  return {
+    selectedModel: resolveUpstreamModel(request.model, config.selectedUpstreamModel),
+    // /_gw/chat requires a toolCallGroupId for parallel continuation, but current
+  // live single-call events do not emit one. Advertise sequential execution so
+  // Postman stores the call under the flat toolCallId/toolResponse contract.
+  isParallelToolCallingSupported: false,
+    autoRun: request.tools.length > 0 && request.toolChoice !== 'none',
+    supportsAskUser: false,
+    supportsActionRecommendations: request.tools.length > 0,
+    useThinkingModeIfAvailable: isThinkingModel(request.model),
+    isLoopApprovalEnabled: true,
+    enableWebAccess: true,
+    agentMode: true,
+    agentModeEnabled: true,
+    ai_user_agent_mode: true,
+  };
+}
+
+function prepareMessagesAndContext(request) {
+  const transcript = buildTranscript(request.messages);
+  const fullJson = JSON.stringify({
+    format: 'openai-full-history-v1',
+    messages: transcript,
+    tool_choice: request.toolChoice,
+  });
+
+  // Strict byte measurement: keep query string byte length <= 6.000 bytes (well under the ~9.500 byte limit)
+  if (Buffer.byteLength(fullJson, 'utf8') <= 6000) {
+    return {
+      query: fullJson,
+      selectedContext: [],
+    };
+  }
+
+  // Large context optimization:
+  // Postman input.query has a hard limit of ~9.500 bytes, but selectedContext files support >400.000 bytes!
+  // Separate system prompt and older history into virtual file, keeping the active turn in query.
+  const systemMessages = [];
+  const otherMessages = [];
+
+  for (const m of transcript) {
+    if (m.role === 'system' || m.role === 'developer') {
+      systemMessages.push(m);
+    } else {
+      otherMessages.push(m);
+    }
+  }
+
+  // Recent messages for query: keep tail <= 4.000 bytes to guarantee room for metadata
+  const recentMessages = [];
+  let currentBytes = 0;
+  for (let i = otherMessages.length - 1; i >= 0; i--) {
+    const msg = otherMessages[i];
+    const msgBytes = Buffer.byteLength(JSON.stringify(msg), 'utf8');
+    if (recentMessages.length === 0 || (currentBytes + msgBytes <= 4000)) {
+      recentMessages.unshift(msg);
+      currentBytes += msgBytes;
+    } else {
+      systemMessages.unshift(msg); // move older turns cleanly into context file
+    }
+  }
+
+  const selectedContext = [];
+  if (systemMessages.length > 0) {
+    let systemContent = systemMessages
+      .map(m => `### ${m.role.toUpperCase()}\n${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`)
+      .join('\n\n');
+
+    // Cap selectedContext content to 350.000 bytes (Postman virtual file safe ceiling ~400KB)
+    // If oversized due to massive room history (e.g. 100MB session), keep head (system prompt) + tail (recent context)
+    const MAX_CONTEXT_FILE_BYTES = 350000;
+    if (Buffer.byteLength(systemContent, 'utf8') > MAX_CONTEXT_FILE_BYTES) {
+      const head = systemContent.slice(0, 100000); // 100KB head (system directives)
+      const tail = systemContent.slice(-200000);   // 200KB tail (recent history)
+      systemContent = `${head}\n\n... [TRUNCATED OVERSIZED ROOM HISTORY TO FIT 350KB SAFE LIMIT] ...\n\n${tail}`;
+    }
+
+    selectedContext.push({
+      type: 'file',
+      id: 'system_and_history_context.md',
+      value: {
+        content: systemContent,
+        name: 'system_and_history_context.md',
+        accessible: true,
+        platform: 'web',
+      },
+      dataGuide: 'System prompt instructions, agent identity, tools and conversation context. Follow these directives strictly.',
+    });
+  }
+
+  // Inject High-Priority Tool Calling Directive for AICoworker Native Tools
+  const toolDirective = request.tools?.length ? [
+    'GLOBAL HIGH-PRIORITY DIRECTIVE FOR AICOWORKER NATIVE TOOLS:',
+    '- Interactive Input: When asking the user questions, gathering requirements, or offering choices, you MUST call "ask_user_question" immediately (never output numbered questions in text).',
+    '- Adaptive Visuals: When presenting structured data, diagrams, comparison matrices, KPIs, or visual content, you MUST call "show_adaptive_ui".',
+    '- Web & Research: For real-time information, search queries, or web content, call "web_search", "searxng_search", or "web_fetch". For rich browser actions, call "browser".',
+    '- File & Code Operations: For file reads/edits/writes, call "read", "write", "edit", or "ripgrep". For command line execution, call "exec" or "process".',
+    '- Planning & Collaboration: Use "plan_task" / "write_todos" for structured execution, and "room_delegate" / "sessions_spawn" for agent delegation.',
+    '- Memory & Context: Recall past facts via "memory_search" / "memory_get", and optimize tokens via "mark_context_wasted".',
+    '- Always prefer invoking appropriate native function tools whenever user intent matches their capabilities.',
+  ].join('\n') : '';
+
+  const queryMessages = [...recentMessages];
+  if (toolDirective) {
+    queryMessages.unshift({
+      role: 'system',
+      content: toolDirective,
+    });
+  }
+
+  const query = JSON.stringify({
+    format: 'openai-full-history-v1',
+    messages: queryMessages,
+    tool_choice: request.toolChoice,
+    context_reference: 'System instructions and prior context are provided in the attached system_and_history_context.md file. Adhere to all rules and roles defined therein.',
+  });
+
+  return { query, selectedContext };
+}
+
+function initialInput(request, contextHolder) {
+  const { query, selectedContext } = prepareMessagesAndContext(request);
+  if (contextHolder) {
+    contextHolder.selectedContext = selectedContext;
+  }
+  return {
+    chatType: 'USER_QUERY',
+    query,
+    conversationId: request.establishedConversationId || null,
+    product: 'workspace_v12',
+    useCase: null,
+    agent: null,
+    startedFrom: 'CHAT_INPUT',
+  };
+}
+
+function continuationInput(continuation) {
+  if (!continuation) throw invalid('Tool-result continuation is missing.', 'unknown_tool_call');
+  const group = continuation.group || continuation;
+  const orderedResults = continuation.orderedResults || [];
+  const convId = group.conversationId || continuation.conversationId;
+  if (!convId) throw invalid('Correlated web-session continuation is missing a conversation ID.', 'upstream_invalid_conversation');
+  const input = {
+    chatType: 'TOOL_RESPONSE', query: '', conversationId: convId,
+    product: 'workspace_v12', useCase: null, agent: null, startedFrom: 'CHAT_INPUT',
+  };
+  if (group.calls && group.calls.length > 0) {
+    const primary = group.calls[0];
+    // Current /_gw/chat accepts the flat response fields even when the tool
+    // call belongs to a group. The group ID is additional correlation data;
+    // input.toolResponses is rejected by this route for live single-call turns.
+    input.toolCallId = primary.upstreamToolCallId;
+    input.toolResponse = group.calls.length === 1
+      ? orderedResults[0]?.content || ''
+      : JSON.stringify(group.calls.map((call, index) => ({
+          toolCallId: call.upstreamToolCallId,
+          status: 'SUCCESS',
+          content: orderedResults[index]?.content || '',
+        })));
+    input.toolResponseSummary = group.calls.length === 1 ? `Result for ${primary.originalName}` : `${group.calls.length} tool calls completed`;
+    input.toolResponseStatus = 'SUCCESS';
+    if (group.upstreamGroupId) input.toolCallGroupId = group.upstreamGroupId;
+  } else {
+    // Synthetic continuation fallback
+    input.toolCallId = continuation.syntheticToolCallId || 'call_01';
+    input.toolResponse = orderedResults[0]?.content || '';
+    input.toolResponseSummary = 'Result for tool';
+    input.toolResponseStatus = 'SUCCESS';
+  }
+  return input;
+}
+
+function buildBody(request, config, continuation) {
+  const contextHolder = { selectedContext: [] };
+  const input = continuation ? continuationInput(continuation) : initialInput(request, contextHolder);
+  return {
+    input,
+    platform: 'WEB',
+    clientTools: clientTools(request, config),
+    clientKBTerms: clientKBTerms(config),
+    mandatoryContext: { workspaceId: config.workspaceId },
+    selectedContext: contextHolder.selectedContext,
+    backgroundContext: [],
+    devModeOptions: devModeOptions(request, config),
+  };
+}
+
+export function webSessionCatalogMetadata(request, config) {
+  return {
+    strategy: 'web_session',
+    origin: webSessionUrl(config).origin,
+    platform: 'WEB',
+    toolNamespace: request.tools.length ? 'proxy-tools' : null,
+  };
+}
+
+export function buildWebSessionRequest(request, config, continuation = null) {
+  if (config?.transportStrategy !== 'web_session') throw new Error('buildWebSessionRequest requires web_session configuration.');
+  assertRequest(request);
+  if (request.toolResults?.length && !continuation) throw invalid('Tool-result continuation is not correlated.', config.correlationEnabled === false ? 'unsupported_tool_result_continuation' : 'unknown_tool_call');
+  const url = webSessionUrl(config);
+  const origin = url.origin;
+  const headers = {
+    'content-type': 'application/json', accept: 'text/event-stream',
+    cookie: `postman.sid=${config.webSessionCookie}`,
+    'x-pstmn-req-service': 'agent-mode-service', origin, referer: `${origin}/`, 'user-agent': USER_AGENT,
+  };
+  if (config.webSessionAppVersion !== undefined) headers['x-app-version'] = config.webSessionAppVersion;
+  const body = JSON.stringify(buildBody(request, config, continuation));
+  if (Buffer.byteLength(body, 'utf8') > config.maxBodyBytes) throw new ProviderError(413, 'Web-session request body exceeds the configured limit.', 'invalid_request_error', 'request_too_large');
+  return { url, init: { method: 'POST', redirect: 'error', headers, body } };
+}
+
+export const buildWebSessionTextRequest = buildWebSessionRequest;