@wlv-zedd/dsh-chatgpt-web 1.0.0

package/src/adapters/chatgpt-web/model.ts

@@ -0,0 +1,70 @@
+import {
+  CHATGPT_WEB_BACKEND_MODEL,
+  CHATGPT_WEB_LUNA_BACKEND_MODEL,
+} from "../../chatgpt-web-models";
+
+export const CHATGPT_WEB_MODEL_ID = CHATGPT_WEB_BACKEND_MODEL;
+export const CHATGPT_WEB_LUNA_MODEL_ID = CHATGPT_WEB_LUNA_BACKEND_MODEL;
+
+export interface ChatGptWebCapabilities {
+  localToolsEnabled: boolean;
+  solAvailable: boolean;
+  proAvailable: boolean;
+}
+
+export interface ChatGptWebModelMode {
+  modelId: string;
+  effort: "low" | "medium" | "high" | "xhigh" | "max";
+  displayLabel: "Luna" | "Think" | "Instant" | "Medium" | "High" | "Extra High" | "Pro";
+  uiEffortIndex: 0 | 1 | 2 | 3 | 4 | null;
+  thinkEnabled: boolean;
+  localTools: boolean;
+}
+
+export function resolveChatGptWebModelMode(
+  modelId: string,
+  reasoning: string | undefined,
+  capabilities: ChatGptWebCapabilities,
+): ChatGptWebModelMode {
+  if (modelId === CHATGPT_WEB_LUNA_MODEL_ID) {
+    if (capabilities.solAvailable) {
+      throw new Error("ChatGPT Luna is not available while the account exposes the Sol model selector");
+    }
+    const effort = reasoning ?? "low";
+    if (effort !== "low" && effort !== "medium") {
+      throw new Error(`ChatGPT Luna mode is not supported: ${effort}`);
+    }
+    const thinkEnabled = effort === "medium";
+    return {
+      modelId,
+      effort,
+      displayLabel: thinkEnabled ? "Think" : "Luna",
+      uiEffortIndex: null,
+      thinkEnabled,
+      localTools: capabilities.localToolsEnabled,
+    };
+  }
+  if (modelId !== CHATGPT_WEB_MODEL_ID) {
+    throw new Error(`ChatGPT web model is not supported: ${modelId}`);
+  }
+  if (!capabilities.solAvailable) {
+    throw new Error("ChatGPT Sol modes are not available for this Luna-only account");
+  }
+  const effort = reasoning ?? "high";
+  switch (effort) {
+    case "low":
+      return { modelId, effort, displayLabel: "Instant", uiEffortIndex: 0, thinkEnabled: false, localTools: capabilities.localToolsEnabled };
+    case "medium":
+      return { modelId, effort, displayLabel: "Medium", uiEffortIndex: 1, thinkEnabled: false, localTools: capabilities.localToolsEnabled };
+    case "high":
+      return { modelId, effort, displayLabel: "High", uiEffortIndex: 2, thinkEnabled: false, localTools: capabilities.localToolsEnabled };
+    case "xhigh":
+      if (!capabilities.proAvailable) throw new Error("ChatGPT Extra High effort is not available for this account");
+      return { modelId, effort, displayLabel: "Extra High", uiEffortIndex: 3, thinkEnabled: false, localTools: capabilities.localToolsEnabled };
+    case "max":
+      if (!capabilities.proAvailable) throw new Error("ChatGPT Pro effort is not available for this account");
+      return { modelId, effort, displayLabel: "Pro", uiEffortIndex: 4, thinkEnabled: false, localTools: capabilities.localToolsEnabled };
+    default:
+      throw new Error(`ChatGPT web effort is not supported: ${effort}`);
+  }
+}

package/src/adapters/chatgpt-web/native-compaction-control.ts

@@ -0,0 +1,74 @@
+import { COMPACT_PROMPT } from "../../responses/compaction";
+import type { CompactionTransactionHandle } from "./compaction-transaction";
+
+export const CODEX_COMPACTION_CONTROL_WIRE_NAME = "codex.control.compaction_handoff";
+export const CODEX_ACTIVE_COMPACTION_REQUEST_MARKER = "CODEX_ACTIVE_COMPACTION_REQUEST";
+
+function compactionControlBinding(transaction: CompactionTransactionHandle): string[] {
+  return [
+    "Submit the complete checkpoint through the attached Codex Native control plane by calling codex_tool_call exactly once with the binding below.",
+    "This one-shot control token is valid only for the reserved compaction operation; do not use it with codex_exec, codex_tool_inventory, or any outer Codex tool.",
+    "<codex_compaction_control>",
+    `turn_token ${transaction.token}`,
+    `wire_name ${CODEX_COMPACTION_CONTROL_WIRE_NAME}`,
+    `handoff_id ${transaction.handoffId}`,
+    "</codex_compaction_control>",
+    `Call codex_tool_call exactly once with ${JSON.stringify({
+      turn_token: transaction.token,
+      wire_name: CODEX_COMPACTION_CONTROL_WIRE_NAME,
+      arguments: {
+        handoff_id: transaction.handoffId,
+        summary: "<complete checkpoint summary>",
+      },
+    })}.`,
+  ];
+}
+
+/**
+ * Stop an active browser response only if it asks for another tool after Codex requested
+ * compaction. Results for calls already handed to Codex remain byte-for-byte canonical: when they
+ * are enough to finish the task, that ordinary final answer remains publishable. A later tool call
+ * is intercepted before execution and receives this instruction; the retained conversation then
+ * receives the sole structured checkpoint request on a clean message boundary.
+ */
+export function activeCompactionToolResultInstruction(): string {
+  return [
+    `<${CODEX_ACTIVE_COMPACTION_REQUEST_MARKER}>`,
+    "Codex reached its context limit before this newly requested tool could be sent for execution. The tool was not executed.",
+    "Stop ordinary task work now, call no more tools, and end this Web response normally.",
+    "Do not create or submit a checkpoint in this response. After it settles, the retained conversation will receive exactly one separate structured compaction handoff request.",
+    `</${CODEX_ACTIVE_COMPACTION_REQUEST_MARKER}>`,
+  ].join("\n");
+}
+
+/**
+ * Zero Risk cannot submit a second browser message automatically. When Codex compacts at an
+ * already-visible native tool boundary, the same manually submitted response returns the
+ * checkpoint through the same Zero Risk request instead.
+ */
+export function zeroRiskActiveCompactionToolResultInstruction(toolExecuted: boolean): string {
+  return [
+    `<${CODEX_ACTIVE_COMPACTION_REQUEST_MARKER}>`,
+    toolExecuted
+      ? "Codex reached its context limit while this Web response was waiting for the tool result above."
+      : "Codex reached its context limit before the requested tool could be sent for execution. The tool was not executed.",
+    toolExecuted
+      ? "Consume that canonical result, stop ordinary task work now, and do not call any more work tools."
+      : "Stop ordinary task work now and do not call any more work tools.",
+    COMPACT_PROMPT,
+    "Call no more work tools. Return only the complete checkpoint summary to Codex with codex_turn_complete.",
+    `</${CODEX_ACTIVE_COMPACTION_REQUEST_MARKER}>`,
+  ].join("\n");
+}
+
+export function structuredCompactionHandoffInstruction(
+  transaction: CompactionTransactionHandle,
+): string {
+  return [
+    "Automatic Codex context compaction has started. Stop ordinary task work and do not call any more work tools.",
+    COMPACT_PROMPT,
+    ...compactionControlBinding(transaction),
+    "After the control call returns submitted=true, call no more tools. The bridge will close this one-purpose Web response after accepting the checkpoint.",
+    "The outer bridge accepts compaction only after the structured checkpoint is valid and its owned browser turn has physically settled.",
+  ].join("\n");
+}

package/src/adapters/chatgpt-web/output-validation.ts

@@ -0,0 +1,62 @@
+import Ajv, { type ValidateFunction } from "ajv";
+import addFormats from "ajv-formats";
+import type { CodexJsonSchemaOutputFormat } from "../../types";
+import { ChatGptWebAdapterError } from "./adapter-error";
+
+export type ChatGptStructuredOutputValidator = (answer: string) => void;
+
+function validationError(message: string): ChatGptWebAdapterError {
+  return new ChatGptWebAdapterError(message, {
+    status: 502,
+    errorType: "server_error",
+    code: "structured_output_validation_failed",
+    retryable: false,
+  });
+}
+
+export function createChatGptStructuredOutputValidator(
+  format: CodexJsonSchemaOutputFormat | undefined,
+): ChatGptStructuredOutputValidator | undefined {
+  if (!format?.strict) return undefined;
+
+  const ajv = new Ajv({
+    allErrors: true,
+    strict: false,
+    coerceTypes: false,
+    removeAdditional: false,
+    useDefaults: false,
+    validateFormats: true,
+  });
+  addFormats(ajv);
+
+  let validate: ValidateFunction;
+  try {
+    validate = ajv.compile(format.schema as object | boolean);
+  } catch (cause) {
+    throw new ChatGptWebAdapterError(
+      `Codex supplied an invalid strict JSON schema ${JSON.stringify(format.name)}: ${cause instanceof Error ? cause.message : String(cause)}`,
+      {
+        status: 400,
+        errorType: "invalid_request_error",
+        code: "invalid_output_schema",
+        retryable: false,
+      },
+    );
+  }
+
+  return (answer: string): void => {
+    let value: unknown;
+    try {
+      value = JSON.parse(answer);
+    } catch {
+      throw validationError(
+        `ChatGPT Web returned malformed JSON for strict Codex output schema ${JSON.stringify(format.name)}`,
+      );
+    }
+    if (validate(value)) return;
+    const detail = ajv.errorsText(validate.errors, { separator: "; " });
+    throw validationError(
+      `ChatGPT Web returned JSON that does not satisfy strict Codex output schema ${JSON.stringify(format.name)}${detail ? `: ${detail}` : ""}`,
+    );
+  };
+}

package/src/adapters/chatgpt-web/process-line-writer.ts

@@ -0,0 +1,46 @@
+import type { Writable } from "node:stream";
+
+function asError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+export interface ProcessLineWriter {
+  write(line: string): boolean;
+  close(): void;
+}
+
+export function createProcessLineWriter(
+  stream: Writable,
+  onFailure: (error: Error) => void,
+): ProcessLineWriter {
+  let writable = true;
+
+  const fail = (error: unknown): void => {
+    if (!writable) return;
+    writable = false;
+    onFailure(asError(error));
+  };
+
+  // A failed Windows anonymous pipe emits an error even when write() also receives
+  // an error callback. Keeping this listener installed prevents an Electron helper
+  // from turning an expected parent disconnect into an uncaught main-process error.
+  stream.on("error", fail);
+
+  return {
+    write(line: string): boolean {
+      if (!writable || stream.destroyed || stream.writableEnded) return false;
+      try {
+        stream.write(`${line}\n`, error => {
+          if (error) fail(error);
+        });
+        return true;
+      } catch (error) {
+        fail(error);
+        return false;
+      }
+    },
+    close(): void {
+      writable = false;
+    },
+  };
+}