@miruzero/zgpt 0.1.0

package/src/conversation/write.js

@@ -0,0 +1,508 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const direct = require('../transport/direct/http-client');
+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 requestConversationInit = async ({
+  conversationId = null,
+  projectId = null,
+  model = null,
+  conversationOrigin = null,
+  systemHints = [],
+  token,
+  sessionHeaders,
+  requestJson = direct.requestJson
+}) => {
+  const target = '/backend-api/conversation/init';
+  const body = {
+    gizmo_id: projectId || null,
+    requested_default_model: model || null,
+    conversation_id: conversationId || null,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || null,
+    timezone_offset_min: new Date().getTimezoneOffset(),
+    conversation_origin: conversationOrigin,
+    ...(Array.isArray(systemHints) && systemHints.length ? { system_hints: [...systemHints] } : {})
+  };
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body, route: target
+  }), target);
+};
+
+exports.initConversation = async (input) => {
+  if (!input?.conversationId) throw new Error('conversationId is required');
+  return requestConversationInit(input);
+};
+
+const initNewConversation = (input) => requestConversationInit({
+  ...input,
+  conversationId: null
+});
+
+const requireSuccess = (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;
+    error.retryAfterMs = direct.parseRetryAfterMs(response?.headers || {});
+    if (error.status === 429) error.code = 'RATE_LIMITED';
+    throw error;
+  }
+  return response.json || { success: true };
+};
+
+const mutateConversation = async ({ conversationId, body, token, sessionHeaders, requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'PATCH', body, route: '/backend-api/conversation/{conversation_id}'
+  }), target);
+};
+
+exports.renameConversation = ({ conversationId, title, token, sessionHeaders, requestJson = direct.requestJson }) =>
+  mutateConversation({ conversationId, body: { title }, token, sessionHeaders, requestJson });
+
+exports.deleteConversation = ({ conversationId, token, sessionHeaders, requestJson = direct.requestJson }) =>
+  mutateConversation({ conversationId, body: { is_visible: false }, token, sessionHeaders, requestJson });
+
+exports.moveConversation = ({ conversationId, projectId, token, sessionHeaders, requestJson = direct.requestJson }) =>
+  mutateConversation({ conversationId, body: { gizmo_id: projectId || null }, token, sessionHeaders, requestJson });
+
+exports.setConversationAsyncStatus = async ({ conversationId, status, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/async-status`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { status }, route: '/backend-api/conversation/{conversation_id}/async-status'
+  }), target);
+};
+
+exports.saveTemporaryConversation = async ({ conversationId, selectedLeafId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!selectedLeafId) throw new Error('selectedLeafId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/save`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { selected_leaf_id: selectedLeafId }, route: '/backend-api/conversation/{conversation_id}/save'
+  }), target);
+};
+
+exports.setMessageReaction = async ({ conversationId, messageId, reaction, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  if (reaction == null) throw new Error('reaction is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/reactions`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { reaction, entrypoint: 'message_action_button' }, route: '/backend-api/conversation/{conversation_id}/messages/{message_id}/reactions'
+  }), target);
+};
+
+exports.removeMessageReaction = async ({ conversationId, messageId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/reactions`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'DELETE', route: '/backend-api/conversation/{conversation_id}/messages/{message_id}/reactions'
+  }), target);
+};
+
+exports.rateConversation = async ({ conversationId, messageId, rating, shownAtAssistantTurn, prompt, popupUiMessage, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/rating`;
+  const body = { message_id: messageId, rating, shown_at_assistant_turn: shownAtAssistantTurn, prompt, popup_ui_message: popupUiMessage };
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body, route: '/backend-api/conversation/{conversation_id}/rating'
+  }), target);
+};
+
+exports.generateConversationTitle = async ({ conversationId, messageId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/gen_title/${encodeURIComponent(conversationId)}`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { message_id: messageId }, route: '/backend-api/conversation/gen_title/{conversation_id}'
+  }), target);
+};
+
+const sendWithRecovery = async ({
+  target, options, conversationId = null, conduitToken, turnTraceId,
+  token, sessionHeaders, requestJson, requestText
+}) => {
+  const progress = sse.createParser();
+  let sawChunk = false;
+  let response = null;
+  let upstreamError = null;
+  try {
+    response = await requestText(target, token, sessionHeaders, {
+      ...options, retry: false, idleTimeoutMs: 60_000,
+      onChunk: (chunk) => { sawChunk = true; progress.push(chunk); options.onChunk?.(chunk); }
+    });
+  } catch (error) { upstreamError = error; }
+  if (response && (response.status < 200 || response.status >= 300)) requireSuccess(response, target);
+  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
+  });
+  if (streamState?.status !== 'IS_STREAMING') {
+    return { response: response || { status: 200, text: '' }, conversationId: observedId, currentNode: state.currentNode };
+  }
+  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); }
+  });
+  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 };
+};
+exports.createConversation = async ({
+  message,
+  projectId = null,
+  model = prepare.DEFAULT_MODEL,
+  thinkingEffort = prepare.DEFAULT_THINKING_EFFORT,
+  systemHints = null,
+  systemHintMentions = null,
+  targetedReply = null,
+  hiddenSystemMessages = [],
+  hideUserMessage = false,
+  localFunctionNames = null,
+  timezone = null,
+  timezoneOffsetMin = null,
+  modelResponseContracts = null,
+  clientContextualInfo = null,
+  temporaryChat = false,
+  historyAndTrainingDisabled = null,
+  isDoNotRemember = null,
+  temporaryChatRequestsPersonalization = null,
+  browserContext = null,
+  attachments = [],
+  enableMessageFollowups = true,
+  forceParallelSwitch = 'auto',
+  paragenCotSummaryDisplayOverride = 'allow',
+  onChunk = null,
+  recoverStream = false,
+  token,
+  sessionHeaders,
+  resolveSystemHintSelections = connector.resolveSystemHintSelections,
+  requestJson = direct.requestJson,
+  requestText = direct.requestText
+}) => {
+  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 : [];
+
+  let preInit = null;
+  let preInitError = null;
+  if (model === 'auto') {
+    try {
+      preInit = await initNewConversation({
+        projectId,
+        model: null,
+        systemHints,
+        token,
+        sessionHeaders,
+        requestJson
+      });
+      model = preInit?.intended_default_model_slug || preInit?.default_model_slug || prepare.DEFAULT_MODEL;
+    } catch (error) {
+      preInitError = error.message || String(error);
+      model = prepare.DEFAULT_MODEL;
+    }
+  }
+
+  const traceId = crypto.randomUUID();
+  const prepareTarget = '/backend-api/f/conversation/prepare';
+  const prepareResponse = await requestJson(prepareTarget, token, sessionHeaders, {
+    method: 'POST',
+    body: prepare.buildPrepareBody({ projectId, model, thinkingEffort, systemHints, localFunctionNames, timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, temporaryChat, attachments }),
+    route: prepareTarget,
+    headers: { 'x-oai-turn-trace-id': traceId }
+  });
+  if (!prepareResponse || prepareResponse.status < 200 || prepareResponse.status >= 300) {
+    requireSuccess(prepareResponse, prepareTarget);
+  }
+  const conduitToken = prepareResponse?.json?.conduit_token
+    || prepareResponse?.headers?.['x-conduit-token'];
+  if (!conduitToken) throw new Error('conversation prepare response missing conduit token');
+  let sentinelHeaders = conduit.takeSentinelHeaders(sessionHeaders || {});
+  try {
+    const fresh = await sentinel.fetchChatRequirements({ token, sessionHeaders: sessionHeaders || {}, requestJson });
+    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 สดไม่สำเร็จ
+  }
+  const sendTarget = '/backend-api/f/conversation';
+  const sendOptions = {
+    method: 'POST',
+    body: prepare.buildSendBody({ message, projectId, model, thinkingEffort, systemHints, systemHintMentions, targetedReply, hiddenSystemMessages, hideUserMessage, timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, localFunctionNames, temporaryChat, historyAndTrainingDisabled, isDoNotRemember, temporaryChatRequestsPersonalization, browserContext, attachments, enableMessageFollowups, forceParallelSwitch, paragenCotSummaryDisplayOverride }),
+    route: sendTarget,
+    headers: {
+      ...sentinelHeaders,
+      'x-conduit-token': conduitToken,
+      'x-oai-turn-trace-id': traceId,
+      accept: 'text/event-stream'
+    },
+    onChunk
+  };
+  const sent = recoverStream
+    ? await sendWithRecovery({
+      target: sendTarget, options: sendOptions, conduitToken, turnTraceId: traceId,
+      token, sessionHeaders, requestJson, requestText
+    })
+    : { response: await requestText(sendTarget, token, sessionHeaders, sendOptions) };
+  const sendResponse = sent.response;
+  if (!sendResponse || sendResponse.status < 200 || sendResponse.status >= 300) {
+    requireSuccess(sendResponse, sendTarget);
+  }
+  const parsedStream = sse.parse(sendResponse.text);
+  const conversationId = sent.conversationId || parsedStream.conversationId;
+  if (!conversationId) throw new Error('conversation response missing conversation_id');
+  if (temporaryChat) {
+    const currentNode = sent.currentNode || parsedStream.currentNode;
+    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 });
+  if (preInit) {
+    conversation.init = preInit;
+  } else {
+    try {
+      conversation.init = await exports.initConversation({ conversationId, projectId, model, token, sessionHeaders, requestJson });
+    } catch (initError) {
+      conversation.init_error = initError.message || String(initError);
+    }
+  }
+  if (preInitError) conversation.init_preflight_error = preInitError;
+  return conversation;
+};
+
+const sendConversationDirect = async ({
+  conversationId,
+  message,
+  parentMessageId = null,
+  projectId = null,
+  model = prepare.DEFAULT_MODEL,
+  thinkingEffort = prepare.DEFAULT_THINKING_EFFORT,
+  systemHints = null,
+  systemHintMentions = null,
+  targetedReply = null,
+  hiddenSystemMessages = [],
+  hideUserMessage = false,
+  localFunctionNames = null,
+  timezone = null,
+  timezoneOffsetMin = null,
+  modelResponseContracts = null,
+  clientContextualInfo = null,
+  temporaryChat = false,
+  historyAndTrainingDisabled = null,
+  isDoNotRemember = null,
+  temporaryChatRequestsPersonalization = null,
+  browserContext = null,
+  attachments = [],
+  enableMessageFollowups = true,
+  forceParallelSwitch = 'auto',
+  paragenCotSummaryDisplayOverride = 'allow',
+  onChunk = null,
+  recoverStream = false,
+  token,
+  sessionHeaders,
+  resolveSystemHintSelections = connector.resolveSystemHintSelections,
+  requestJson = direct.requestJson,
+  requestText = direct.requestText
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  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 : [];
+  let resolvedParentMessageId = parentMessageId;
+  let resolvedProjectId = projectId;
+  if (!temporaryChat) {
+    const before = await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
+    resolvedParentMessageId = before.current_node;
+    resolvedProjectId = before.gizmo_id || null;
+  }
+  if (!resolvedParentMessageId) throw new Error('conversation current_node is required');
+  let sentinelHeaders = conduit.takeSentinelHeaders(sessionHeaders);
+  try {
+    const fresh = await sentinel.fetchChatRequirements({ token, sessionHeaders, requestJson });
+    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 สดไม่สำเร็จ
+  }
+  const turnHeaders = { ...sessionHeaders };
+  for (const name of conduit.SENTINEL_HEADER_NAMES) delete turnHeaders[name];
+  const traceId = crypto.randomUUID();
+  const prepareTarget = '/backend-api/f/conversation/prepare';
+  const prepareBody = {
+    ...prepare.buildPrepareBody({ projectId: resolvedProjectId, model, thinkingEffort, systemHints, localFunctionNames, timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, temporaryChat, attachments, includeForkFromSharedPost: false }),
+    conversation_id: conversationId,
+    parent_message_id: resolvedParentMessageId,
+    client_prepare_dispatch: 'immediate',
+    client_prepare_source: 'context_change'
+  };
+  const prepareResponse = await requestJson(prepareTarget, token, turnHeaders, {
+    method: 'POST', body: prepareBody, route: prepareTarget,
+    headers: { 'x-oai-turn-trace-id': traceId }
+  });
+  if (!prepareResponse || prepareResponse.status < 200 || prepareResponse.status >= 300) requireSuccess(prepareResponse, prepareTarget);
+  conduit.applyIntegrityUpdate(turnHeaders, prepareResponse.headers, 'r');
+  let conduitToken = prepareResponse?.json?.conduit_token || prepareResponse?.headers?.['x-conduit-token'];
+  if (!conduitToken) throw new Error('conversation prepare response missing conduit token');
+  const preparedBody = {
+    ...prepareBody,
+    client_prepare_state: 'success',
+    client_prepare_dispatch: 'debounced',
+    client_prepare_source: 'composer_editor_state'
+  };
+  const preparedResponse = await requestJson(prepareTarget, token, turnHeaders, {
+    method: 'POST', body: preparedBody, route: prepareTarget,
+    headers: {
+      'x-conduit-token': conduitToken,
+      'x-oai-turn-trace-id': traceId,
+      'x-oai-is-client-observation': turnHeaders['x-oai-is-client-observation']
+    }
+  });
+  if (!preparedResponse || preparedResponse.status < 200 || preparedResponse.status >= 300) requireSuccess(preparedResponse, prepareTarget);
+  conduit.applyIntegrityUpdate(turnHeaders, preparedResponse.headers, 'r');
+  conduitToken = preparedResponse?.headers?.['x-conduit-token'] || conduitToken;
+  const sendTarget = '/backend-api/f/conversation';
+  const sendBody = {
+    ...prepare.buildSendBody({ message, projectId: resolvedProjectId, model, thinkingEffort, systemHints, systemHintMentions, targetedReply, hiddenSystemMessages, hideUserMessage, timezone, timezoneOffsetMin, modelResponseContracts, clientContextualInfo, localFunctionNames, temporaryChat, historyAndTrainingDisabled, isDoNotRemember, temporaryChatRequestsPersonalization, browserContext, attachments, enableMessageFollowups, forceParallelSwitch, paragenCotSummaryDisplayOverride }),
+    conversation_id: conversationId,
+    parent_message_id: resolvedParentMessageId
+  };
+  const sendOptions = {
+    method: 'POST', body: sendBody, route: sendTarget,
+    headers: {
+      ...sentinelHeaders,
+      'x-conduit-token': conduitToken,
+      'x-oai-turn-trace-id': traceId,
+      'x-oai-is-client-observation': conduit.streamObservation(turnHeaders['x-oai-is-client-observation']),
+      accept: 'text/event-stream'
+    },
+    onChunk
+  };
+  const sent = recoverStream
+    ? await sendWithRecovery({
+      target: sendTarget, options: sendOptions, conversationId, conduitToken, turnTraceId: traceId,
+      token, sessionHeaders: turnHeaders, requestJson, requestText
+    })
+    : { response: await requestText(sendTarget, token, turnHeaders, sendOptions) };
+  const sendResponse = sent.response;
+  if (!sendResponse || sendResponse.status < 200 || sendResponse.status >= 300) requireSuccess(sendResponse, sendTarget);
+  if (temporaryChat) {
+    const parsedStream = sse.parse(sendResponse.text);
+    const currentNode = sent.currentNode || parsedStream.currentNode;
+    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,
+      previous_node: resolvedParentMessageId,
+      temporary_chat: true,
+      messages: []
+    };
+  }
+  const after = await read.getConversation({ conversationId, token, sessionHeaders, requestJson });
+  if (after && typeof after === 'object') after.previous_node = resolvedParentMessageId;
+  return after;
+};
+exports.sendConversation = async ({ transport = 'direct', ...input }) => {
+  if (transport !== 'direct') {
+    const error = new Error('Unsupported ChatGPT transport: ' + transport);
+    error.code = 'UNSUPPORTED_TRANSPORT';
+    throw error;
+  }
+  return sendConversationDirect(input);
+};
+
+exports.setConversationAsyncStatus = async ({
+  conversationId, status = null, token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/async-status`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { status }, route: '/backend-api/conversation/{conversation_id}/async-status', retry: false
+  }), target);
+};
+
+exports.setMessageReaction = async ({
+  conversationId, messageId, reaction, entrypoint = 'message_action_button',
+  token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  if (!reaction) throw new Error('reaction is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/reactions`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { reaction, entrypoint },
+    route: '/backend-api/conversation/{conversation_id}/messages/{message_id}/reactions', retry: false
+  }), target);
+};
+
+exports.removeMessageReaction = async ({
+  conversationId, messageId, token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(messageId)}/reactions`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'DELETE', route: '/backend-api/conversation/{conversation_id}/messages/{message_id}/reactions', retry: false
+  }), target);
+};
+
+exports.rateConversation = async ({
+  conversationId, messageId, rating, shownAtAssistantTurn = -1,
+  prompt = null, popupUiMessage = null,
+  token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/rating`;
+  const body = {
+    message_id: messageId, rating,
+    shown_at_assistant_turn: shownAtAssistantTurn,
+    prompt, popup_ui_message: popupUiMessage
+  };
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body, route: '/backend-api/conversation/{conversation_id}/rating', retry: false
+  }), target);
+};
+
+exports.generateConversationTitle = async ({
+  conversationId, messageId, token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/conversation/gen_title/${encodeURIComponent(conversationId)}`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { message_id: messageId },
+    route: '/backend-api/conversation/gen_title/{conversation_id}', retry: false
+  }), target);
+};
+
+exports.saveTemporaryConversation = async ({
+  conversationId, selectedLeafId, token, sessionHeaders, requestJson = direct.requestJson
+}) => {
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!selectedLeafId) throw new Error('selectedLeafId is required');
+  const target = `/backend-api/conversation/${encodeURIComponent(conversationId)}/save`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { selected_leaf_id: selectedLeafId },
+    route: '/backend-api/conversation/{conversation_id}/save', retry: false
+  }), target);
+};

package/src/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+exports.auth = require('./auth');
+exports.session = require('./session');
+exports.conversation = require('./conversation');
+exports.project = require('./project');
+exports.connector = require('./connector');
+exports.api = require('./api');

package/src/project/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const read = require('./read');
+const write = require('./write');
+
+Object.assign(exports, read, write);

package/src/project/read.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const direct = require('../transport/direct/http-client');
+
+const requireOk = (response, target) => {
+  if (!response || response.status !== 200 || !response.json) {
+    const error = new Error(`ChatGPT request failed (${response?.status || 'no-status'}): ${target}`);
+    error.status = response?.status || null;
+    error.target = target;
+    error.retryAfterMs = direct.parseRetryAfterMs(response?.headers || {});
+    if (error.status === 429) error.code = 'RATE_LIMITED';
+    throw error;
+  }
+  return response.json;
+};
+
+exports.listProjects = async ({ token, sessionHeaders, requestJson = direct.requestJson }) => {
+  const projects = [];
+  let cursor = null;
+  for (let pageNumber = 0; pageNumber < 1000; pageNumber += 1) {
+    const cursorPart = cursor ? `&cursor=${encodeURIComponent(cursor)}` : '';
+    const target = `/backend-api/gizmos/snorlax/sidebar?owned_only=true&conversations_per_gizmo=5&limit=20${cursorPart}`;
+    let page;
+    try {
+      page = requireOk(await requestJson(target, token, sessionHeaders), target);
+    } catch (error) {
+      if (error.status === 401 || error.status === 403 || error.status === 404) return projects;
+      throw error;
+    }
+    for (const item of Array.isArray(page.items) ? page.items : []) {
+      const gizmo = item?.gizmo?.gizmo;
+      if (!gizmo?.id) continue;
+      projects.push({ id: gizmo.id, name: gizmo.display?.name || gizmo.short_url || gizmo.id });
+    }
+    if (!page.cursor || page.cursor === cursor) return projects;
+    cursor = page.cursor;
+  }
+  throw Object.assign(new Error('project pagination exceeded 1000 pages'), { code: 'PAGINATION_LIMIT' });
+};
+
+exports.getProject = async ({ projectId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!projectId) throw new Error('projectId is required');
+  const target = `/backend-api/gizmos/${encodeURIComponent(projectId)}`;
+  return requireOk(await requestJson(target, token, sessionHeaders, { route: '/backend-api/gizmos/{gizmo_id}' }), target);
+};
+
+exports.listProjectConversationPage = async ({ projectId, token, sessionHeaders, cursor = '0', limit = 50, requestJson = direct.requestJson }) => {
+  if (!projectId) throw new Error('projectId is required');
+  const target = `/backend-api/gizmos/${encodeURIComponent(projectId)}/conversations?cursor=${encodeURIComponent(cursor)}&limit=${limit}&owned_only=true`;
+  const page = requireOk(await requestJson(target, token, sessionHeaders, { route: '/backend-api/gizmos/{gizmo_id}/conversations' }), target);
+  return { items: Array.isArray(page.items) ? page.items : [], cursor, nextCursor: page.cursor && page.cursor !== cursor ? page.cursor : null };
+};
+
+exports.listProjectConversations = async ({ projectId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  const items = [];
+  let cursor = '0';
+  for (let pageNumber = 0; pageNumber < 1000; pageNumber += 1) {
+    const page = await exports.listProjectConversationPage({ projectId, token, sessionHeaders, cursor, limit: 50, requestJson });
+    items.push(...page.items);
+    if (!page.nextCursor) return items;
+    cursor = page.nextCursor;
+  }
+  throw Object.assign(new Error('project conversation pagination exceeded 1000 pages'), { code: 'PAGINATION_LIMIT' });
+};
+
+exports.listAll = async ({ token, sessionHeaders, requestJson = direct.requestJson, onProgress = () => {} }) => {
+  const conversation = require('../conversation/read');
+  const conversationPage = await conversation.listConversationPage({ token, sessionHeaders, requestJson, onProgress });
+  onProgress({ type: 'standalone-loaded', count: conversationPage.items.length, total: conversationPage.total });
+  const projectList = await exports.listProjects({ token, sessionHeaders, requestJson });
+  onProgress({ type: 'projects-loaded', count: projectList.length });
+  const projects = projectList.map((project) => ({ ...project, conversations: [] }));
+  const projectsById = new Map(projects.map((project) => [project.id, project]));
+  const outside = [];
+  for (const item of conversationPage.items) {
+    const project = item.gizmo_id ? projectsById.get(item.gizmo_id) : null;
+    if (project) project.conversations.push(item);
+    else outside.push(item);
+  }
+  const result = {
+    outside,
+    projects,
+    returned: conversationPage.items.length,
+    total: conversationPage.total,
+    offset: conversationPage.offset,
+    limit: conversationPage.limit,
+    nextOffset: conversationPage.nextOffset
+  };
+  onProgress({ type: 'done', returned: result.returned, total: result.total });
+  return result;
+};

package/src/project/write.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const direct = require('../transport/direct/http-client');
+const read = require('./read');
+
+const requireSuccess = (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;
+    error.retryAfterMs = direct.parseRetryAfterMs(response?.headers || {});
+    if (error.status === 429) error.code = 'RATE_LIMITED';
+    throw error;
+  }
+  return response.json || { success: true };
+};
+
+exports.createProject = async ({ name, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  const target = '/backend-api/projects';
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { name, instructions: '', memory_scope: 'project_v2' }, route: target
+  }), target);
+};
+
+exports.renameProject = async ({ projectId, name, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  const raw = await read.getProject({ projectId, token, sessionHeaders, requestJson });
+  const g = raw?.gizmo?.gizmo || raw?.gizmo || raw || {};
+  const display = g.display || {};
+  const target = `/backend-api/projects/${encodeURIComponent(projectId)}`;
+  const body = { name, instructions: g.instructions || '', emoji: display.emoji ?? null, theme: display.theme ?? null };
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'PATCH', body, route: '/backend-api/projects/{project_id}'
+  }), target);
+};
+
+exports.saveProjectMessage = async ({ projectId, conversationId, messageId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!projectId) throw new Error('projectId is required');
+  if (!conversationId) throw new Error('conversationId is required');
+  if (!messageId) throw new Error('messageId is required');
+  const target = `/backend-api/projects/${encodeURIComponent(projectId)}/saves`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, {
+    method: 'POST', body: { conversation_id: conversationId, message_id: messageId }, route: '/backend-api/projects/{project_id}/saves', retry: false
+  }), target);
+};
+
+exports.deleteProject = async ({ projectId, token, sessionHeaders, requestJson = direct.requestJson }) => {
+  if (!projectId) throw new Error('projectId is required');
+  const target = `/backend-api/gizmos/${encodeURIComponent(projectId)}`;
+  return requireSuccess(await requestJson(target, token, sessionHeaders, { method: 'DELETE', route: '/backend-api/gizmos/{gizmo_id}' }), target);
+};