@miruzero/zgpt 0.1.0 → 0.1.1

package/src/conversation/recovery.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const read = require('./read');
+const stateStore = require('./recovery-state');
+const sse = require('../protocol/sse');
+
+const coded = (code, message, extra = {}) => Object.assign(new Error(message), { code, ...extra });
+
+const verifyCanonical = async ({ checkpoint, env, token, sessionHeaders, requestJson }) => {
+  const conversation = await read.getConversation({
+    conversationId: checkpoint.conversation_id, token, sessionHeaders, requestJson
+  });
+  const currentNode = conversation?.current_node || null;
+  const parentNode = checkpoint.parent_message_id || null;
+  if (!currentNode || (parentNode && currentNode === parentNode)) {
+    throw coded('STREAM_CANONICAL_UNVERIFIED', 'conversation canonical state has not advanced');
+  }
+  stateStore.remove(checkpoint.conversation_id, env);
+  return conversation;
+};
+
+exports.retry = async ({
+  conversationId, env = process.env, token, sessionHeaders,
+  requestJson, requestText, onChunk = null
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  const checkpoint = stateStore.get(conversationId, env);
+  if (!checkpoint) throw coded('STREAM_RECOVERY_STATE_MISSING', 'conversation recovery checkpoint is missing');
+
+  if (checkpoint.phase === 'verify') {
+    return verifyCanonical({ checkpoint, env, token, sessionHeaders, requestJson });
+  }
+
+  const streamState = await read.getConversationStreamStatus({
+    conversationId, turnTraceId: checkpoint.turn_trace_id, token, sessionHeaders, requestJson
+  });
+  const status = streamState?.status || null;
+
+  if (status === 'FAILURE') throw coded('STREAM_FAILED', 'conversation stream reported failure');
+  if (status === 'COMPLETE' || status === 'IS_STOP_REQUESTED' || status === 'UNAVAILABLE') {
+    stateStore.save({
+      conversationId, phase: 'verify', offset: checkpoint.offset,
+      resumeToken: checkpoint.resume_token, turnTraceId: checkpoint.turn_trace_id,
+      parentMessageId: checkpoint.parent_message_id, currentNode: checkpoint.current_node
+    }, env);
+    return verifyCanonical({ checkpoint: stateStore.get(conversationId, env), env, token, sessionHeaders, requestJson });
+  }
+  if (status !== 'IS_STREAMING') {
+    throw coded('STREAM_STATUS_UNKNOWN', `unknown conversation stream status: ${status || 'missing'}`);
+  }
+  if (!checkpoint.resume_token) {
+    throw coded('STREAM_RESUME_TOKEN_REQUIRED', 'resume token required for frozen streaming conversation');
+  }
+
+  const parser = sse.createParser();
+  let sawChunk = false;
+  let response;
+  try {
+    response = await read.resumeConversation({
+      conversationId,
+      offset: checkpoint.offset,
+      conduitToken: checkpoint.resume_token,
+      turnTraceId: checkpoint.turn_trace_id,
+      token, sessionHeaders, requestText,
+      onChunk: (chunk) => { sawChunk = true; parser.push(chunk); onChunk?.(chunk); }
+    });
+  } catch (error) {
+    if (!error.code) error.code = 'STREAM_RESUME_FAILED';
+    throw error;
+  }
+  if (response?.text && !sawChunk) parser.push(response.text);
+  const resumed = parser.finish();
+  const nextOffset = checkpoint.offset + (resumed.resumeOffset || 0);
+  stateStore.save({
+    conversationId,
+    phase: resumed.completed ? 'verify' : 'stream',
+    offset: nextOffset,
+    resumeToken: resumed.resumeToken || checkpoint.resume_token,
+    turnTraceId: checkpoint.turn_trace_id,
+    parentMessageId: checkpoint.parent_message_id,
+    currentNode: resumed.currentNode || checkpoint.current_node
+  }, env);
+  if (!resumed.completed) throw coded('STREAM_INCOMPLETE', 'resumed conversation stream ended before [DONE]');
+  return verifyCanonical({ checkpoint: stateStore.get(conversationId, env), env, token, sessionHeaders, requestJson });
+};

package/src/conversation/temporary.js

@@ -23,6 +23,7 @@ exports.createConversation = async ({
 }) => {
   const result = await write.createConversation({
     ...options,
+    env,
     message,
     temporaryChat: true,
     historyAndTrainingDisabled: true,
@@ -46,6 +47,7 @@ exports.sendConversation = async ({
   }
   const result = await write.sendConversation({
     ...options,
+    env,
     conversationId,
     message,
     parentMessageId: cursor.current_node,
@@ -56,4 +58,4 @@ exports.sendConversation = async ({
   });
   tempState.save({ conversationId, currentNode: result.current_node, env });
   return result;
-};
+};

package/src/conversation/write.js

@@ -6,8 +6,10 @@ const sentinel = require('../protocol/sentinel-client');
 const prepare = require('../protocol/conversation-payload');
 const conduit = require('../protocol/conduit');
 const sse = require('../protocol/sse');
-const read = require('./read');
-const connector = require('../connector');
+const read = require('./read');
+const recoveryState = require('./recovery-state');
+const connector = require('../connector');
+const contextConfig = require('./context-config');
 
 const requestConversationInit = async ({
   conversationId = null,
@@ -129,7 +131,8 @@ exports.generateConversationTitle = async ({ conversationId, messageId, token, s
 };
 
 const sendWithRecovery = async ({
-  target, options, conversationId = null, conduitToken, turnTraceId,
+  target, options, conversationId = null, parentMessageId = null, turnTraceId,
+  env = process.env, persistRecovery = true,
   token, sessionHeaders, requestJson, requestText
 }) => {
   const progress = sse.createParser();
@@ -146,25 +149,96 @@ const sendWithRecovery = async ({
   if (response?.text && !sawChunk) progress.push(response.text);
   const state = progress.finish();
   const observedId = state.conversationId || conversationId;
-  if (state.completed) return { response: response || { status: 200, text: '' }, conversationId: observedId, currentNode: state.currentNode };
-  if (!observedId) { if (upstreamError) throw upstreamError; throw Object.assign(new Error('conversation stream ended before conversation_id was available'), { code: 'STREAM_INCOMPLETE' }); }
-  const streamState = await read.getConversationStreamStatus({
-    conversationId: observedId, token, sessionHeaders, requestJson
+  const checkpoint = (phase, cursor = {}) => ({
+    conversationId: observedId,
+    phase,
+    offset: cursor.offset ?? state.resumeOffset ?? 0,
+    resumeToken: cursor.resumeToken ?? state.resumeToken ?? null,
+    turnTraceId,
+    parentMessageId,
+    currentNode: cursor.currentNode ?? state.currentNode ?? null
   });
+  const freeze = (error, value) => {
+    if (persistRecovery && observedId) recoveryState.save(value, env);
+    throw error;
+  };
+  if (state.completed) {
+    return {
+      response: response || { status: 200, text: '' }, conversationId: observedId,
+      currentNode: state.currentNode, recoveryCheckpoint: observedId ? checkpoint('verify') : null
+    };
+  }
+  if (!observedId) {
+    if (upstreamError) throw upstreamError;
+    throw Object.assign(new Error('conversation stream ended before conversation_id was available'), { code: 'STREAM_INCOMPLETE' });
+  }
+  const interruptedCheckpoint = checkpoint('stream');
+  let streamState;
+  try {
+    streamState = await read.getConversationStreamStatus({
+      conversationId: observedId, turnTraceId, token, sessionHeaders, requestJson
+    });
+  } catch (error) {
+    freeze(error, interruptedCheckpoint);
+  }
+  if (streamState?.status === 'FAILURE') {
+    freeze(Object.assign(new Error('conversation stream reported failure'), { code: 'STREAM_FAILED' }), checkpoint('stream'));
+  }
+  if (['COMPLETE', 'IS_STOP_REQUESTED', 'UNAVAILABLE'].includes(streamState?.status)) {
+    return {
+      response: response || { status: 200, text: '' }, conversationId: observedId,
+      currentNode: state.currentNode, recoveryCheckpoint: checkpoint('verify')
+    };
+  }
   if (streamState?.status !== 'IS_STREAMING') {
-    return { response: response || { status: 200, text: '' }, conversationId: observedId, currentNode: state.currentNode };
+    freeze(Object.assign(new Error(`unknown conversation stream status: ${streamState?.status || 'missing'}`), { code: 'STREAM_STATUS_UNKNOWN' }), checkpoint('stream'));
+  }
+  const resumeOffset = state.resumeOffset || 0;
+  const streamCheckpoint = checkpoint('stream', { offset: resumeOffset, resumeToken: state.resumeToken });
+  if (!state.resumeToken) {
+    freeze(Object.assign(new Error('resume token required for interrupted streaming conversation'), { code: 'STREAM_RESUME_TOKEN_REQUIRED' }), streamCheckpoint);
   }
   const resumedProgress = sse.createParser();
   let resumedSawChunk = false;
-  const resumed = await read.resumeConversation({
-    conversationId: observedId, offset: 0, conduitToken: state.resumeToken || conduitToken, turnTraceId,
-    token, sessionHeaders, requestJson, requestText,
-    onChunk: (chunk) => { resumedSawChunk = true; resumedProgress.push(chunk); options.onChunk?.(chunk); }
-  });
+  let resumed;
+  try {
+    resumed = await read.resumeConversation({
+      conversationId: observedId, offset: resumeOffset, conduitToken: state.resumeToken, turnTraceId,
+      token, sessionHeaders, requestText,
+      onChunk: (chunk) => { resumedSawChunk = true; resumedProgress.push(chunk); options.onChunk?.(chunk); }
+    });
+  } catch (error) {
+    if (!error.code) error.code = 'STREAM_RESUME_FAILED';
+    freeze(error, streamCheckpoint);
+  }
   if (resumed.text && !resumedSawChunk) resumedProgress.push(resumed.text);
   const resumedState = resumedProgress.finish();
-  if (!resumedState.completed) throw Object.assign(new Error('resumed conversation stream ended before [DONE]'), { code: 'STREAM_INCOMPLETE' });
-  return { response: response || { status: 200, text: '' }, conversationId: observedId, currentNode: resumedState.currentNode || state.currentNode };
+  const nextCheckpoint = checkpoint(resumedState.completed ? 'verify' : 'stream', {
+    offset: resumeOffset + (resumedState.resumeOffset || 0),
+    resumeToken: resumedState.resumeToken || state.resumeToken,
+    currentNode: resumedState.currentNode || state.currentNode
+  });
+  if (!resumedState.completed) {
+    freeze(Object.assign(new Error('resumed conversation stream ended before [DONE]'), { code: 'STREAM_INCOMPLETE' }), nextCheckpoint);
+  }
+  return {
+    response: response || { status: 200, text: '' }, conversationId: observedId,
+    currentNode: resumedState.currentNode || state.currentNode, recoveryCheckpoint: nextCheckpoint
+  };
+};
+
+const canonicalAfterDispatch = async ({ conversationId, parentMessageId = null, checkpoint = null, env = process.env, token, sessionHeaders, requestJson }) => {
+  try {
+    const conversation = await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
+    if (!conversation?.current_node || (parentMessageId && conversation.current_node === parentMessageId)) {
+      throw Object.assign(new Error('conversation canonical state has not advanced'), { code: 'STREAM_CANONICAL_UNVERIFIED' });
+    }
+    recoveryState.remove(conversationId, env);
+    return conversation;
+  } catch (error) {
+    if (checkpoint) recoveryState.save(checkpoint, env);
+    throw error;
+  }
 };
 exports.createConversation = async ({
   message,
@@ -191,17 +265,22 @@ exports.createConversation = async ({
   forceParallelSwitch = 'auto',
   paragenCotSummaryDisplayOverride = 'allow',
   onChunk = null,
-  recoverStream = false,
+  recoverStream = null,
+  env = process.env,
   token,
   sessionHeaders,
   resolveSystemHintSelections = connector.resolveSystemHintSelections,
   requestJson = direct.requestJson,
   requestText = direct.requestText
 }) => {
+  const shouldRecoverStream = recoverStream == null ? !temporaryChat : recoverStream === true;
   if (!message) throw new Error('message is required');
   if (!Array.isArray(systemHints) && !Array.isArray(systemHintMentions)) ({ systemHints, systemHintMentions } = await resolveSystemHintSelections({ message, token, sessionHeaders }));
   systemHints = Array.isArray(systemHints) ? systemHints : [];
-  systemHintMentions = Array.isArray(systemHintMentions) ? systemHintMentions : [];
+  systemHintMentions = Array.isArray(systemHintMentions) ? systemHintMentions : [];
+  ({ systemHints, localFunctionNames, hiddenSystemMessages } = contextConfig.merge({
+    env, systemHints, localFunctionNames, hiddenSystemMessages
+  }));
 
   let preInit = null;
   let preInitError = null;
@@ -242,7 +321,7 @@ exports.createConversation = async ({
     if (fresh?.token) sentinelHeaders = { ...sentinelHeaders, 'openai-sentinel-chat-requirements-token': fresh.token };
     if (fresh?.proofToken) sentinelHeaders = { ...sentinelHeaders, 'openai-sentinel-proof-token': fresh.proofToken };
   } catch {
-    // fallback: ใช้ sentinel headers จาก session เดิมถ้า fetch สดไม่สำเร็จ
+    // fallback: reuse sentinel headers from the current session when refresh fails
   }
   const sendTarget = '/backend-api/f/conversation';
   const sendOptions = {
@@ -257,9 +336,9 @@ exports.createConversation = async ({
     },
     onChunk
   };
-  const sent = recoverStream
+  const sent = shouldRecoverStream
     ? await sendWithRecovery({
-      target: sendTarget, options: sendOptions, conduitToken, turnTraceId: traceId,
+      target: sendTarget, options: sendOptions, turnTraceId: traceId, env, persistRecovery: !temporaryChat,
       token, sessionHeaders, requestJson, requestText
     })
     : { response: await requestText(sendTarget, token, sessionHeaders, sendOptions) };
@@ -275,7 +354,9 @@ exports.createConversation = async ({
     if (!currentNode) throw Object.assign(new Error('temporary conversation response missing current node'), { code: 'TEMP_CURRENT_NODE_MISSING' });
     return { conversation_id: conversationId, current_node: currentNode, temporary_chat: true, messages: [] };
   }
-  const conversation = await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
+  const conversation = shouldRecoverStream
+    ? await canonicalAfterDispatch({ conversationId, checkpoint: sent.recoveryCheckpoint, env, token, sessionHeaders, requestJson })
+    : await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
   if (preInit) {
     conversation.init = preInit;
   } else {
@@ -316,18 +397,26 @@ const sendConversationDirect = async ({
   forceParallelSwitch = 'auto',
   paragenCotSummaryDisplayOverride = 'allow',
   onChunk = null,
-  recoverStream = false,
+  recoverStream = null,
+  env = process.env,
   token,
   sessionHeaders,
   resolveSystemHintSelections = connector.resolveSystemHintSelections,
   requestJson = direct.requestJson,
   requestText = direct.requestText
 }) => {
+  const shouldRecoverStream = recoverStream == null ? !temporaryChat : recoverStream === true;
   if (!conversationId) throw new Error('conversationId is required');
+  if (!temporaryChat && recoveryState.get(conversationId, env)) {
+    throw Object.assign(new Error('conversation has a frozen recovery checkpoint; retry it before sending a new message'), { code: 'STREAM_RECOVERY_PENDING' });
+  }
   if (!message) throw new Error('message is required');
   if (!Array.isArray(systemHints) && !Array.isArray(systemHintMentions)) ({ systemHints, systemHintMentions } = await resolveSystemHintSelections({ message, token, sessionHeaders }));
   systemHints = Array.isArray(systemHints) ? systemHints : [];
-  systemHintMentions = Array.isArray(systemHintMentions) ? systemHintMentions : [];
+  systemHintMentions = Array.isArray(systemHintMentions) ? systemHintMentions : [];
+  ({ systemHints, localFunctionNames, hiddenSystemMessages } = contextConfig.merge({
+    env, systemHints, localFunctionNames, hiddenSystemMessages
+  }));
   let resolvedParentMessageId = parentMessageId;
   let resolvedProjectId = projectId;
   if (!temporaryChat) {
@@ -342,7 +431,7 @@ const sendConversationDirect = async ({
     if (fresh?.token) sentinelHeaders = { ...sentinelHeaders, 'openai-sentinel-chat-requirements-token': fresh.token };
     if (fresh?.proofToken) sentinelHeaders = { ...sentinelHeaders, 'openai-sentinel-proof-token': fresh.proofToken };
   } catch {
-    // fallback: ใช้ sentinel headers จาก session เดิมถ้า fetch สดไม่สำเร็จ
+    // fallback: reuse sentinel headers from the current session when refresh fails
   }
   const turnHeaders = { ...sessionHeaders };
   for (const name of conduit.SENTINEL_HEADER_NAMES) delete turnHeaders[name];
@@ -397,9 +486,9 @@ const sendConversationDirect = async ({
     },
     onChunk
   };
-  const sent = recoverStream
+  const sent = shouldRecoverStream
     ? await sendWithRecovery({
-      target: sendTarget, options: sendOptions, conversationId, conduitToken, turnTraceId: traceId,
+      target: sendTarget, options: sendOptions, conversationId, parentMessageId: resolvedParentMessageId, turnTraceId: traceId, env, persistRecovery: !temporaryChat,
       token, sessionHeaders: turnHeaders, requestJson, requestText
     })
     : { response: await requestText(sendTarget, token, turnHeaders, sendOptions) };
@@ -417,7 +506,9 @@ const sendConversationDirect = async ({
       messages: []
     };
   }
-  const after = await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
+  const after = shouldRecoverStream
+    ? await canonicalAfterDispatch({ conversationId, parentMessageId: resolvedParentMessageId, checkpoint: sent.recoveryCheckpoint, env, token, sessionHeaders, requestJson })
+    : await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
   if (after && typeof after === 'object') after.previous_node = resolvedParentMessageId;
   return after;
 };

package/src/file/index.js

@@ -0,0 +1,151 @@
+'use strict';
+const https = require('node:https');
+const direct = require('../transport/direct/http-client');
+const context = require('../runtime-context');
+
+const required = (value, name) => {
+  if (typeof value !== 'string' || !value) throw Object.assign(new Error(`${name} is required`), { code: 'BAD_ARGS' });
+  return value;
+};
+const require2xx = (response, target) => {
+  if (!response || response.status < 200 || response.status >= 300) {
+    const error = new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`);
+    error.status = response?.status || null;
+    error.target = target;
+    if (error.status === 429) error.code = 'RATE_LIMITED';
+    throw error;
+  }
+  return response;
+};
+const normalizeReservation = (input) => {
+  if (!input || input.eligible !== true) throw Object.assign(new Error('upload reservation is not eligible'), { code: 'UPLOAD_RESERVATION_UNAVAILABLE' });
+  return {
+    fileId: required(input.reservation_id, 'reservation_id'),
+    uploadUrl: required(input.upload_url, 'upload_url'),
+    uploadUrlExpiresAt: required(input.upload_url_expires_at, 'upload_url_expires_at'),
+    reservationExpiresAt: required(input.reservation_expires_at, 'reservation_expires_at')
+  };
+};
+const uploadDefaults = (options) => ({
+  entrySurface: options.entrySurface || 'chat_composer',
+  storeInLibrary: options.storeInLibrary === true,
+  libraryPersistenceMode: options.libraryPersistenceMode || 'opportunistic'
+});
+
+exports.createUploadReservation = async (options = {}) => {
+  options = await context.bind(options);
+  const intendedUseCase = required(options.intendedUseCase, 'intendedUseCase');
+  const d = uploadDefaults(options);
+  const target = '/backend-api/files/upload_reservations';
+  const response = require2xx(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, {
+    method: 'POST', retry: false, route: target,
+    body: { intended_use_case: intendedUseCase, entry_surface: d.entrySurface, requires_gizmo_id: false, store_in_library: d.storeInLibrary, library_persistence_mode: d.libraryPersistenceMode }
+  }), target);
+  return normalizeReservation(response.json);
+};
+
+exports.createFileEntry = async (options = {}) => {
+  options = await context.bind(options);
+  const name = required(options.name, 'name');
+  const useCase = required(options.useCase, 'useCase');
+  if (!Number.isFinite(options.size) || options.size < 0) throw Object.assign(new Error('size is required'), { code: 'BAD_ARGS' });
+  const d = uploadDefaults(options);
+  const target = '/backend-api/files';
+  const body = {
+    file_name: name, file_size: options.size, use_case: useCase,
+    timezone_offset_min: Number.isFinite(options.timezoneOffsetMin) ? options.timezoneOffsetMin : new Date().getTimezoneOffset(),
+    reset_rate_limits: options.resetRateLimits === true, supports_direct_azure_multipart: true,
+    entry_surface: d.entrySurface, store_in_library: d.storeInLibrary, library_persistence_mode: d.libraryPersistenceMode
+  };
+  if (options.mimeType) body.mime_type = options.mimeType;
+  const response = require2xx(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'POST', retry: false, route: target, body }), target);
+  return response.json || {};
+};
+
+exports.claimUploadReservation = async (options = {}) => {
+  options = await context.bind(options);
+  const reservationId = required(options.reservationId, 'reservationId');
+  const name = required(options.name, 'name');
+  const useCase = required(options.useCase, 'useCase');
+  if (!Number.isFinite(options.size) || options.size < 0) throw Object.assign(new Error('size is required'), { code: 'BAD_ARGS' });
+  const d = uploadDefaults(options);
+  const target = `/backend-api/files/upload_reservations/${encodeURIComponent(reservationId)}/claim_and_finish`;
+  const body = {
+    file_name: name, file_size: options.size, use_case: useCase,
+    index_for_retrieval: options.indexForRetrieval === true,
+    store_in_library: d.storeInLibrary, library_persistence_mode: d.libraryPersistenceMode,
+    entry_surface: d.entrySurface
+  };
+  if (options.mimeType) body.mime_type = options.mimeType;
+  if (options.metadata) body.metadata = options.metadata;
+  const headers = options.modelSlug ? { 'x-oai-model-slug': options.modelSlug } : undefined;
+  const response = require2xx(await (options.requestText || direct.requestText)(target, options.token, options.sessionHeaders, { method: 'POST', retry: false, route: '/backend-api/files/upload_reservations/{reservation_id}/claim_and_finish', body, ...(headers ? { headers } : {}) }), target);
+  return response.text ?? '';
+};
+
+exports.processUpload = async (options = {}) => {
+  options = await context.bind(options);
+  const fileId = required(options.fileId, 'fileId');
+  const name = required(options.name, 'name');
+  const mimeType = required(options.mimeType, 'mimeType');
+  const d = uploadDefaults(options);
+  const useCase = options.useCase || (mimeType.startsWith('image/') ? 'multimodal' : 'my_files');
+  const target = '/backend-api/files/process_upload_stream';
+  const body = {
+    entry_surface: d.entrySurface, file_id: fileId, file_name: name,
+    index_for_retrieval: options.indexForRetrieval ?? !mimeType.startsWith('image/'),
+    library_persistence_mode: d.libraryPersistenceMode,
+    metadata: { is_temporary_chat: options.temporary === true, store_in_library: d.storeInLibrary, is_project_thread: options.isProjectThread === true },
+    mime_type: mimeType, use_case: useCase
+  };
+  const response = require2xx(await (options.requestText || direct.requestText)(target, options.token, options.sessionHeaders, { method: 'POST', retry: false, route: target, body }), target);
+  return response.text ?? '';
+};
+
+
+
+
+const signedTargetForLog = (value) => {
+  try {
+    const url = new URL(value);
+    return url.origin + url.pathname + (url.search ? '?<redacted>' : '');
+  } catch { return '<invalid-upload-url>'; }
+};
+const hasHeader = (headers, name) => Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+const putSignedBytes = (url, data, headers) => new Promise((resolve, reject) => {
+  const req = https.request(url, { method: 'PUT', headers }, (res) => {
+    res.resume();
+    res.on('end', () => resolve({ status: Number(res.statusCode || 0), headers: { ...res.headers } }));
+    res.on('error', reject);
+  });
+  req.on('error', reject);
+  req.end(data);
+});
+
+exports.uploadBytes = async (options = {}) => {
+  const uploadUrl = required(options.uploadUrl, 'uploadUrl');
+  let parsed;
+  try { parsed = new URL(uploadUrl); } catch { throw Object.assign(new Error('uploadUrl is invalid'), { code: 'BAD_ARGS' }); }
+  if (parsed.protocol !== 'https:') throw Object.assign(new Error('uploadUrl must use https'), { code: 'BAD_ARGS' });
+  const data = Buffer.isBuffer(options.data) ? options.data : Buffer.from(options.data ?? '');
+  const headers = { ...(options.uploadHeaders || {}) };
+  if (options.mimeType && !hasHeader(headers, 'content-type')) headers['content-type'] = options.mimeType;
+  if (!hasHeader(headers, 'content-length')) headers['content-length'] = String(data.length);
+  let response;
+  try { response = await (options.putBytes || putSignedBytes)(uploadUrl, data, headers); }
+  catch (cause) {
+    const error = new Error('ChatGPT signed file upload transport failed');
+    error.code = 'FILE_BLOB_UPLOAD_FAILED';
+    error.target = signedTargetForLog(uploadUrl);
+    error.cause = cause;
+    throw error;
+  }
+  if (!response || response.status < 200 || response.status >= 300) {
+    const error = new Error(`ChatGPT signed file upload failed (${response?.status || 'no-status'})`);
+    error.code = 'FILE_BLOB_UPLOAD_FAILED';
+    error.status = response?.status || null;
+    error.target = signedTargetForLog(uploadUrl);
+    throw error;
+  }
+  return { status: response.status, headers: response.headers || {} };
+};

package/src/index.js

@@ -5,4 +5,8 @@ exports.session = require('./session');
 exports.conversation = require('./conversation');
 exports.project = require('./project');
 exports.connector = require('./connector');
-exports.api = require('./api');
+exports.file = require('./file');
+exports.memory = require('./memory');
+exports.settings = require('./settings');
+exports.share = require('./share');
+

package/src/memory/index.js

@@ -0,0 +1,64 @@
+'use strict';
+const direct = require('../transport/direct/http-client');
+const context = require('../runtime-context');
+
+const requireOk = (response, target) => {
+  if (!response || response.status !== 200 || !response.json) {
+    throw Object.assign(new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`), { status: response?.status || null, target });
+  }
+  return response.json;
+};
+const requireSuccess = (response, target) => {
+  if (!response || response.status < 200 || response.status >= 300) {
+    throw Object.assign(new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`), { status: response?.status || null, target });
+  }
+  return response.json || { success: true };
+};
+const requiredId = (value, name) => {
+  if (typeof value !== 'string' || !value) throw Object.assign(new Error(`${name} is required`), { code: 'BAD_ARGS' });
+  return encodeURIComponent(value);
+};
+
+exports.list = async (options = {}) => {
+  options = await context.bind(options);
+  const includeMemoryEntries = options.includeMemoryEntries === true;
+  const target = `/backend-api/memories?include_memory_entries=${includeMemoryEntries ? 'true' : 'false'}`;
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { route: '/backend-api/memories' }), target);
+};
+
+exports.setStatus = async (options = {}) => {
+  options = await context.bind(options);
+  const memoryId = requiredId(options.memoryId, 'memoryId');
+  const status = typeof options.status === 'string' ? options.status.trim() : '';
+  if (!status) throw Object.assign(new Error('status is required'), { code: 'BAD_ARGS' });
+  const target = `/backend-api/memories/${memoryId}/status`;
+  return requireSuccess(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'PATCH', retry: false, route: '/backend-api/memories/{memory_id}/status', body: { status } }), target);
+};
+
+exports.remove = async (options = {}) => {
+  options = await context.bind(options);
+  const memoryId = requiredId(options.memoryId, 'memoryId');
+  const target = `/backend-api/memories/${memoryId}`;
+  return requireSuccess(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'DELETE', retry: false, route: '/backend-api/memories/{memory_id}' }), target);
+};
+
+exports.listHistory = async (options = {}) => {
+  options = await context.bind(options);
+  const limit = Number.isSafeInteger(options.limit) && options.limit > 0 ? options.limit : 50;
+  const target = `/backend-api/memories/history?limit=${limit}`;
+  return requireOk(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { route: '/backend-api/memories/history' }), target);
+};
+
+exports.revertHistory = async (options = {}) => {
+  options = await context.bind(options);
+  const historyId = requiredId(options.historyId, 'historyId');
+  const target = `/backend-api/memories/history/${historyId}/revert`;
+  return requireSuccess(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'POST', retry: false, route: '/backend-api/memories/history/{memory_history_id}/revert', body: {} }), target);
+};
+
+exports.removeHistory = async (options = {}) => {
+  options = await context.bind(options);
+  const historyId = requiredId(options.historyId, 'historyId');
+  const target = `/backend-api/memories/history/${historyId}`;
+  return requireSuccess(await (options.requestJson || direct.requestJson)(target, options.token, options.sessionHeaders, { method: 'DELETE', retry: false, route: '/backend-api/memories/history/{memory_history_id}' }), target);
+};

package/src/protocol/sse.js

@@ -1,7 +1,8 @@
 'use strict';
 
 const stateOf = (events, completed, conversationId, currentNode, resumeToken, malformed) => ({
-  events: [...events], completed, conversationId, currentNode, resumeToken, malformed
+  events: [...events], completed, conversationId, currentNode, resumeToken, malformed,
+  resumeOffset: events.length
 });
 
 exports.createParser = () => {

package/src/runtime-context.js

@@ -0,0 +1,27 @@
+'use strict';
+const fs = require('node:fs');
+const auth = require('./auth');
+const paths = require('./config/paths');
+
+const injectedTransport = (options) => !options.env && (typeof options.requestJson === 'function' || typeof options.requestText === 'function');
+
+exports.bind = async (options = {}) => {
+  const resolved = { ...options };
+  if (resolved.token && resolved.sessionHeaders) return resolved;
+  if (injectedTransport(resolved)) return resolved;
+  const env = resolved.env || process.env;
+  if (!resolved.token) {
+    const current = await auth.ensure({ env });
+    resolved.token = current.accessToken;
+  }
+  if (!resolved.sessionHeaders) {
+    let state;
+    try { state = JSON.parse(fs.readFileSync(paths.sessionFile(env), 'utf8')); }
+    catch { throw Object.assign(new Error('ChatGPT session context required'), { code: 'SESSION_REQUIRED' }); }
+    if (!state?.headers || typeof state.headers !== 'object' || Array.isArray(state.headers)) {
+      throw Object.assign(new Error('ChatGPT session context required'), { code: 'SESSION_REQUIRED' });
+    }
+    resolved.sessionHeaders = { ...state.headers };
+  }
+  return resolved;
+};