@jskit-ai/assistant-core 0.1.240 → 0.1.241

package/src/server/conversation/codexProvider.js

@@ -8,21 +8,24 @@ import {
 } from "./codexConfiguration.js";
 import {
   CODEX_APP_SERVER_PROCESS_STATE, CODEX_APP_SERVER_TRANSPORT,
-  assertExistingDirectory, codexAppServerCommandBaseEnv, codexAppServerCredentialHome,
   codexAppServerExecutionMode, codexAppServerHelperWorkspaceDir, codexAppServerIsHelper,
-  codexAppServerProcessCwd, codexAppServerRuntimeIdentity, codexAppServerTerminalEnvHash,
+  codexAppServerRuntimeIdentity, codexAppServerTerminalEnvHash,
   ensureWritablePrivateDirectory, normalizeCodexAppServerTerminalEnv, tailTextFile
 } from "./codexProcess.js";
+import { assertCodexAuthPreflightReady } from "./codexAuthPreflight.js";
+import { codexAppServerModelCatalogError } from "./codexModelCatalog.js";
 import { prepareCodexHistory } from "./codexHistoryAdapter.js";
 import { createCodexConversationAdapter } from "./providers/codex.js";
 import { exportCodexNativeHistory } from "./codexNativeHistoryExport.js";
 import { retireNativeConversation, readStoppedNativeDatabase } from "./nativeHistoryExport.js";
-import { isPlainObject, normalizeText as normalizeAgentText } from "./normalize.js";
+import { isRecord, normalizePositiveInteger } from "@jskit-ai/kernel/shared/support/normalize";
+import { normalizeNullableText as normalizeAgentText } from "./normalize.js";
 import {
   codexAppServerProviderThreadTurns,
   codexAppServerProviderTurnItems,
   codexAppServerProviderTurnClientIds,
-  codexAppServerThreadRawValue
+  codexAppServerThreadRawValue,
+  codexAppServerErrorText
 } from "./codexEvents.js";
 
 const CODEX_APP_SERVER_PROVIDER_ID = "codex_app_server";
@@ -30,8 +33,6 @@ const CODEX_APP_SERVER_EXECUTION_MODES = Object.freeze({ HELPER: "helper", INTER
 const codexAppServerHelperAuthError = createCodexAccountReader().error;
 
 const CODEX_APP_SERVER_INVALID_REQUEST_CODE = -32600;
-const CODEX_RENEWAL_UNMATERIALIZED_THREAD_SUFFIX =
-  "is not materialized yet; includeTurns is unavailable before first user message";
 const CODEX_APP_SERVER_MODEL_CATALOG_PAGE_LIMIT = 100;
 const CODEX_APP_SERVER_MODEL_CATALOG_MAX_PAGES = 100;
 const CODEX_APP_SERVER_MODEL_CATALOG_MAX_ENTRIES = 1000;
@@ -40,23 +41,16 @@ const CODEX_APP_SERVER_MODEL_CATALOG_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
 const CODEX_APP_SERVER_MODEL_CATALOG_MAX_CURSOR_LENGTH = 512;
 const CODEX_APP_SERVER_THREAD_INVENTORY_PAGE_LIMIT = 100;
 const CODEX_APP_SERVER_THREAD_INVENTORY_MAX_PAGES = 100;
-const CODEX_APP_SERVER_THREAD_INVENTORY_MAX_COUNT = 1000;
-const CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH = 512;
+export const CODEX_APP_SERVER_THREAD_INVENTORY_MAX_COUNT = 1000;
+export const CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH = 512;
 const CODEX_APP_SERVER_THREAD_INVENTORY_MAX_ENTRY_BYTES = 64 * 1024;
 const CODEX_APP_SERVER_THREAD_INVENTORY_MAX_TOTAL_BYTES = 2 * 1024 * 1024;
 const CODEX_APP_SERVER_HELPER_MAX_MESSAGE_BYTES = 4 * 1024 * 1024;
 const CODEX_APP_SERVER_SERVER_INFO_USER_AGENT_MAX_LENGTH = 512;
-const CODEX_AUTH_PREFLIGHT_TIMEOUT_MS = 15000;
-const CODEX_AUTH_PREFLIGHT_OUTPUT_TAIL_BYTES = 4096;
 const CODEX_APP_SERVER_CHATGPT_REFRESH_METHOD = "account/chatgptAuthTokens/refresh";
 const CODEX_NATIVE_STORAGE_SOURCE_KINDS = ["cli", "vscode", "exec", "appServer", "subAgent", "subAgentReview",
   "subAgentCompact", "subAgentThreadSpawn", "subAgentOther", "unknown"];
 
-function normalizePositiveInteger(value, fallback) {
-  const number = Number(value);
-  return Number.isSafeInteger(number) && number > 0 ? number : fallback;
-}
-
 function codexAppServerRequestIsInvalid(error = null, method = "") {
   const expectedMethod = normalizeAgentText(method);
   const actualMethod = normalizeAgentText(error?.method);
@@ -206,7 +200,7 @@ async function inspectCodexAppServerMessageAdmission({ provider, threadId, messa
 // proof and durable cleanup receipt.
 async function deleteCodexAppServerThread({ provider, threadId } = {}) {
   const result = await provider.deleteThread(threadId);
-  if (!isPlainObject(result)) {
+  if (!isRecord(result)) {
     const error = new Error("Codex app-server returned an invalid thread deletion result.");
     error.code = "codex_helper_thread_delete_unconfirmed";
     throw error;
@@ -354,501 +348,6 @@ async function ensureCodexAppServerThread({
   };
 }
 
-function defineCodexRenewalThreadIds(value = [], {
-  errorCode = "codex_renewal_fresh_thread_required"
-} = {}) {
-  if (
-    !Array.isArray(value) ||
-    value.length > CODEX_APP_SERVER_THREAD_INVENTORY_MAX_COUNT
-  ) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The successor assistant thread inventory is invalid."
-    );
-  }
-  const threadIds = value.map((threadId) => normalizeAgentText(threadId));
-  if (
-    threadIds.some((threadId) => (
-      !threadId ||
-      threadId.length > CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH ||
-      codexAppServerTextHasControlCharacters(threadId)
-    )) ||
-    new Set(threadIds).size !== threadIds.length
-  ) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The successor assistant thread inventory contains an invalid identity."
-    );
-  }
-  return Object.freeze([...threadIds].sort());
-}
-
-async function listCodexRenewalThreadIds(provider, workdir, errorCode) {
-  if (typeof provider?.listAppServerThreadsForCwd !== "function") {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The assistant provider cannot inventory the successor's exact session threads."
-    );
-  }
-  const normalizedWorkdir = normalizeAgentText(workdir);
-  const inventory = await provider.listAppServerThreadsForCwd({
-    cwd: normalizedWorkdir
-  });
-  if (normalizeAgentText(inventory?.cwd) !== normalizedWorkdir) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The assistant provider returned a thread inventory for a different session source."
-    );
-  }
-  return defineCodexRenewalThreadIds(inventory?.threadIds, { errorCode });
-}
-
-function assertCodexRenewalThreadSnapshot(threadSnapshot = null, {
-  threadId = "",
-  workdir = "",
-  errorCode
-} = {}) {
-  const expectedThreadId = normalizeAgentText(threadId);
-  const expectedWorkdir = normalizeAgentText(workdir);
-  const actualThreadId = codexAppServerThreadResponseId(threadSnapshot);
-  const actualWorkdir = normalizeAgentText(
-    threadSnapshot?.cwd ||
-    threadSnapshot?.raw?.cwd ||
-    threadSnapshot?.response?.thread?.cwd
-  );
-  if (actualThreadId !== expectedThreadId || actualWorkdir !== expectedWorkdir) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The assistant provider could not verify the exact successor thread and session source.",
-      {
-        actualThreadId,
-        actualWorkdir,
-        expectedThreadId,
-        expectedWorkdir
-      }
-    );
-  }
-  return threadSnapshot;
-}
-
-function codexRenewalThreadNeedsStatusRead(error = null, threadId = "") {
-  const normalizedThreadId = normalizeAgentText(threadId);
-  return Boolean(
-    normalizedThreadId &&
-    (
-      (
-        codexAppServerRequestIsInvalid(error, "thread/read") &&
-        normalizeAgentText(error?.message) ===
-          `thread ${normalizedThreadId} ${CODEX_RENEWAL_UNMATERIALIZED_THREAD_SUFFIX}`
-      ) ||
-      (
-        Number(error?.code) === -32601 &&
-        normalizeAgentText(error?.method) === "thread/read"
-      )
-    )
-  );
-}
-
-async function readCodexRenewalSuccessorThreadSnapshot({
-  provider,
-  threadId = "",
-  workdir = "",
-  errorCode
-} = {}) {
-  try {
-    return assertCodexRenewalThreadSnapshot(
-      await provider.readThread(threadId),
-      { threadId, workdir, errorCode }
-    );
-  } catch (error) {
-    if (
-      !codexRenewalThreadNeedsStatusRead(error, threadId) ||
-      typeof provider?.readThreadStatus !== "function"
-    ) {
-      throw error;
-    }
-    return assertCodexRenewalThreadSnapshot(
-      await provider.readThreadStatus(threadId),
-      { threadId, workdir, errorCode }
-    );
-  }
-}
-
-function codexRenewalThreadError(code, message, details = {}, {
-  retryable = false
-} = {}) {
-  const error = new Error(message);
-  error.code = code;
-  error.details = {
-    ...details,
-    retryable
-  };
-  error.retryable = retryable;
-  return error;
-}
-
-function codexAppServerThreadResponseId(thread = null, fallback = "") {
-  return normalizeAgentText(
-    thread?.id ||
-    thread?.response?.thread?.id ||
-    fallback
-  );
-}
-
-/** Resume only the supplied retained thread; native read failures never replace it. */
-async function resumeExactCodexAppServerThread({
-  expectedThreadId = "",
-  provider,
-  settings,
-  projectHooks = false,
-  workdir = "",
-  errorCode = "codex_renewal_thread_unreadable"
-} = {}) {
-  const normalizedWorkdir = normalizeAgentText(workdir);
-  const normalizedExpectedThreadId = normalizeAgentText(expectedThreadId);
-  if (
-    typeof provider?.ensureRuntime !== "function" ||
-    typeof provider?.resumeThread !== "function" ||
-    typeof provider?.readThread !== "function"
-  ) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The old assistant provider cannot read its exact main thread.",
-      { expectedThreadId: normalizedExpectedThreadId }
-    );
-  }
-  const appServerRuntime = await provider.ensureRuntime();
-  const config = projectHooks
-    ? await codexAppServerProjectHookTrustConfig(provider, normalizedWorkdir)
-    : null;
-  const { threadSettings } = await settings(normalizedWorkdir, config);
-  let thread = null;
-  let threadSnapshot = null;
-  try {
-    thread = await provider.resumeThread(normalizedExpectedThreadId, threadSettings);
-    const resumedThreadId = codexAppServerThreadResponseId(thread, normalizedExpectedThreadId);
-    if (resumedThreadId !== normalizedExpectedThreadId) {
-      throw codexRenewalThreadError(
-        errorCode,
-        "The old assistant provider resumed a different thread.",
-        {
-          expectedThreadId: normalizedExpectedThreadId,
-          resumedThreadId
-        }
-      );
-    }
-    threadSnapshot = await provider.readThread(normalizedExpectedThreadId);
-  } catch (error) {
-    if (
-      error?.code === errorCode ||
-      codexAppServerRequestIsInvalid(error, "thread/resume") ||
-      codexAppServerRequestIsInvalid(error, "thread/read")
-    ) {
-      if (error?.code === errorCode) {
-        throw error;
-      }
-      throw codexRenewalThreadError(
-        errorCode,
-        "The old assistant thread cannot be read. Write or edit the handover manually instead.",
-        {
-          expectedThreadId: normalizedExpectedThreadId,
-          providerError: normalizeAgentText(error?.message)
-        }
-      );
-    }
-    throw error;
-  }
-  return Object.freeze({
-    appServerRuntime,
-    thread,
-    threadId: normalizedExpectedThreadId,
-    threadSnapshot,
-    threadSettings
-  });
-}
-
-/** Preserve the original baseline → create/adopt → durable identity → first-read order. */
-async function startFreshCodexAppServerThread({
-  provider,
-  settings,
-  projectHooks = false,
-  identity,
-  resumableThreadId = "",
-  forbiddenThreadId = "",
-  operationId = "",
-  workdir = "",
-  errorCode = "codex_renewal_fresh_thread_required",
-  applicationName = "The application"
-} = {}) {
-  const normalizedWorkdir = normalizeAgentText(workdir);
-  const normalizedForbiddenThreadId = normalizeAgentText(forbiddenThreadId);
-  const normalizedOperationId = normalizeAgentText(operationId);
-  if (resumableThreadId && resumableThreadId === normalizedForbiddenThreadId) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The renewed session cannot reuse the old session's assistant thread.",
-      { forbiddenThreadId: normalizedForbiddenThreadId }
-    );
-  }
-  if (
-    typeof provider?.ensureRuntime !== "function" ||
-    typeof provider?.resumeThread !== "function" ||
-    typeof provider?.readThread !== "function" ||
-    typeof provider?.startThread !== "function"
-  ) {
-    throw codexRenewalThreadError(
-      errorCode,
-      "The assistant provider cannot prove a genuinely fresh renewal thread."
-    );
-  }
-  const appServerRuntime = await provider.ensureRuntime();
-  const config = projectHooks
-    ? await codexAppServerProjectHookTrustConfig(provider, normalizedWorkdir)
-    : null;
-  const { threadSettings, threadStartSettings } = await settings(normalizedWorkdir, config);
-  let fresh = false;
-  let thread = null;
-  let threadSnapshot = null;
-  let baselineThreadIds = Object.freeze([]);
-  if (resumableThreadId) {
-    try {
-      thread = await provider.resumeThread(resumableThreadId, threadSettings);
-      const resumedThreadId = codexAppServerThreadResponseId(thread, resumableThreadId);
-      if (resumedThreadId !== resumableThreadId) {
-        throw codexRenewalThreadError(
-          errorCode,
-          "The assistant provider resumed a different renewal thread.",
-          {
-            expectedThreadId: resumableThreadId,
-            resumedThreadId
-          }
-        );
-      }
-      threadSnapshot = await readCodexRenewalSuccessorThreadSnapshot({
-        provider,
-        threadId: resumableThreadId,
-        workdir: normalizedWorkdir,
-        errorCode
-      });
-    } catch (error) {
-      if (
-        error?.code === errorCode ||
-        codexAppServerRequestIsInvalid(error, "thread/resume") ||
-        codexAppServerRequestIsInvalid(error, "thread/read")
-      ) {
-        if (error?.code === errorCode) {
-          throw error;
-        }
-        throw codexRenewalThreadError(
-          errorCode,
-          `The previously started renewal thread is no longer readable; ${applicationName} will not replace it silently.`,
-          {
-            expectedThreadId: resumableThreadId,
-            providerError: normalizeAgentText(error?.message)
-          }
-        );
-      }
-      throw error;
-    }
-  } else {
-    if (!normalizedOperationId) {
-      throw codexRenewalThreadError(
-        errorCode,
-        "Starting a fresh successor thread requires its exact renewal operation id."
-      );
-    }
-    baselineThreadIds = await identity.readBaseline();
-    if (!baselineThreadIds) {
-      baselineThreadIds = await listCodexRenewalThreadIds(
-        provider,
-        normalizedWorkdir,
-        errorCode
-      );
-      await identity.writeBaseline(baselineThreadIds);
-    }
-    const currentThreadIds = await listCodexRenewalThreadIds(
-      provider,
-      normalizedWorkdir,
-      errorCode
-    );
-    const baseline = new Set(baselineThreadIds);
-    const candidateThreadIds = currentThreadIds.filter((threadId) => !baseline.has(threadId));
-    if (candidateThreadIds.length > 1) {
-      throw codexRenewalThreadError(
-        errorCode,
-        `More than one unclaimed assistant thread appeared for this renewal; ${applicationName} will not guess which one is authoritative.`,
-        { candidateThreadIds }
-      );
-    }
-    if (candidateThreadIds.length === 1) {
-      const [candidateThreadId] = candidateThreadIds;
-      thread = await provider.resumeThread(candidateThreadId, threadSettings);
-      const resumedThreadId = codexAppServerThreadResponseId(thread, candidateThreadId);
-      if (resumedThreadId !== candidateThreadId) {
-        throw codexRenewalThreadError(
-          errorCode,
-          "The assistant provider resumed a different recovered renewal thread.",
-          {
-            expectedThreadId: candidateThreadId,
-            resumedThreadId
-          }
-        );
-      }
-      threadSnapshot = await readCodexRenewalSuccessorThreadSnapshot({
-        provider,
-        threadId: candidateThreadId,
-        workdir: normalizedWorkdir,
-        errorCode
-      });
-    } else {
-      thread = await provider.startThread(threadStartSettings);
-      fresh = true;
-    }
-  }
-  const threadId = codexAppServerThreadResponseId(thread, resumableThreadId);
-  if (
-    !threadId ||
-    threadId === normalizedForbiddenThreadId ||
-    (fresh && baselineThreadIds.includes(threadId))
-  ) {
-    throw codexRenewalThreadError(
-      errorCode,
-      threadId
-        ? "The assistant provider reused the old session's thread instead of starting a fresh one."
-        : "The assistant provider did not return a fresh renewal thread id.",
-      {
-        forbiddenThreadId: normalizedForbiddenThreadId,
-        threadId
-      }
-    );
-  }
-  await identity.write({ appServerRuntime, threadId, workdir: normalizedWorkdir });
-  if (fresh) {
-    try {
-      threadSnapshot = await readCodexRenewalSuccessorThreadSnapshot({
-        provider,
-        threadId,
-        workdir: normalizedWorkdir,
-        errorCode
-      });
-    } catch (error) {
-      throw codexRenewalThreadError(
-        errorCode,
-        `The newly started renewal thread cannot be read; ${applicationName} will not replace it silently.`,
-        {
-          providerError: normalizeAgentText(error?.message),
-          threadId
-        },
-        { retryable: true }
-      );
-    }
-  }
-  return Object.freeze({
-    appServerRuntime,
-    fresh,
-    thread,
-    threadId,
-    threadSnapshot,
-    threadStartSettings,
-    threadSettings
-  });
-}
-
-function codexAppServerModelCatalogError(message = "", errorPrefix = "") {
-  const error = new Error(normalizeAgentText(message) || "Codex returned an invalid model catalog.");
-  error.code = `${errorPrefix}codex_model_catalog_invalid`;
-  return error;
-}
-
-function codexAppServerProviderConnectionGeneration(provider = null) {
-  const generation = typeof provider?.currentConnectionGeneration === "function"
-    ? provider.currentConnectionGeneration()
-    : typeof provider?.connectionGeneration === "function"
-      ? provider.connectionGeneration()
-      : provider?.connectionGeneration;
-  return normalizeAgentText(generation || "");
-}
-
-function codexAppServerModelCatalogSnapshot(value = null, errorPrefix = "") {
-  if (!Array.isArray(value?.data)) {
-    throw codexAppServerModelCatalogError("Codex did not return a usable live model catalog.", errorPrefix);
-  }
-  return Object.freeze({
-    data: Object.freeze(value.data.map((model = {}) => Object.freeze({
-      hidden: model.hidden === true,
-      model: normalizeAgentText(model.model || ""),
-      supportedReasoningEfforts: Object.freeze((Array.isArray(model.supportedReasoningEfforts)
-        ? model.supportedReasoningEfforts
-        : []).map((option = {}) => Object.freeze({
-        reasoningEffort: normalizeAgentText(option.reasoningEffort || "")
-      })))
-    })))
-  });
-}
-
-function createCodexAppServerModelCatalogCache({
-  cacheMs = 30_000,
-  errorPrefix = ""
-} = {}) {
-  const codexAppServerModelCatalogs = new WeakMap();
-  return async function readCodexAppServerModelCatalog(provider, { signal = null } = {}) {
-    if (typeof provider.listModels !== "function") {
-      const error = new Error("Codex live model discovery is unavailable.");
-      error.code = `${errorPrefix}codex_model_catalog_unavailable`;
-      throw error;
-    }
-    const connectionGeneration = codexAppServerProviderConnectionGeneration(provider);
-    const now = Date.now();
-    const cached = codexAppServerModelCatalogs.get(provider);
-    if (
-      cached?.connectionGeneration === connectionGeneration &&
-      cached.value &&
-      cached.expiresAt > now
-    ) {
-      return cached.value;
-    }
-    if (
-      cached?.connectionGeneration === connectionGeneration &&
-      cached.pending
-    ) {
-      return cached.pending;
-    }
-
-    const pending = provider.listModels({
-      includeHidden: false,
-      limit: 100
-    }, { signal }).then((result) => {
-      if (codexAppServerProviderConnectionGeneration(provider) !== connectionGeneration) {
-        const error = new Error("Codex reconnected while resolving the helper model catalog.");
-        error.code = `${errorPrefix}codex_model_catalog_stale`;
-        throw error;
-      }
-      return codexAppServerModelCatalogSnapshot(result, errorPrefix);
-    });
-    codexAppServerModelCatalogs.set(provider, {
-      connectionGeneration,
-      expiresAt: 0,
-      pending,
-      value: null
-    });
-    try {
-      const value = await pending;
-      codexAppServerModelCatalogs.set(provider, {
-        connectionGeneration,
-        expiresAt: Date.now() + cacheMs,
-        pending: null,
-        value
-      });
-      return value;
-    } catch (error) {
-      if (codexAppServerModelCatalogs.get(provider)?.pending === pending) {
-        codexAppServerModelCatalogs.delete(provider);
-      }
-      throw error;
-    }
-  };
-}
-
 function codexAppServerHelperLoginParams(auth = {}, errorPrefix = "") {
   if (auth.authMode === "chatgpt") {
     return {
@@ -901,7 +400,7 @@ function codexAppServerHelperRequestError(error = null, reason = "", errorPrefix
 }
 
 function normalizeCodexAppServerInfo(initializeResult = null) {
-  if (!isPlainObject(initializeResult)) {
+  if (!isRecord(initializeResult)) {
     return null;
   }
   const rawUserAgent = initializeResult.userAgent;
@@ -918,77 +417,6 @@ function normalizeCodexAppServerInfo(initializeResult = null) {
   });
 }
 
-function tailAppend(text = "", chunk = "", maxBytes = CODEX_AUTH_PREFLIGHT_OUTPUT_TAIL_BYTES) {
-  const next = `${String(text || "")}${String(chunk || "")}`;
-  return next.length > maxBytes ? next.slice(-maxBytes) : next;
-}
-
-function codexAuthPreflightArgs() {
-  return [
-    "-c",
-    "check_for_update_on_startup=false",
-    "debug",
-    "models"
-  ];
-}
-
-async function runCodexAuthPreflight({
-  codexCommand = "codex",
-  env = process.env,
-  executionRoot = "",
-  runtimeDir = "",
-  terminalEnv = {},
-  timeoutMs = CODEX_AUTH_PREFLIGHT_TIMEOUT_MS,
-  toolHomeSource = "",
-  workdir = ""
-} = {}, execution) {
-  const normalizedToolHomeSource = normalizeAgentText(toolHomeSource);
-  if (normalizedToolHomeSource) {
-    await assertExistingDirectory(normalizedToolHomeSource, "Codex credential home");
-  }
-  const normalizedRuntimeDir = normalizeAgentText(runtimeDir);
-  if (normalizedRuntimeDir) {
-    await ensureWritablePrivateDirectory(path.resolve(normalizedRuntimeDir));
-  }
-  const baseEnv = codexAppServerCommandBaseEnv({
-    env,
-    terminalEnv
-  });
-  const processCwd = codexAppServerProcessCwd({
-    executionRoot,
-    runtimeDir,
-    workdir
-  });
-  try {
-    const result = await execution.run({
-      args: codexAuthPreflightArgs(),
-      baseEnv,
-      command: codexCommand,
-      credentialHome: codexAppServerCredentialHome(normalizedToolHomeSource, baseEnv),
-      cwd: processCwd,
-      inheritProcessEnv: false,
-      mode: "capture",
-      timeout: normalizePositiveInteger(timeoutMs, CODEX_AUTH_PREFLIGHT_TIMEOUT_MS)
-    });
-    return {
-      code: result.exitCode,
-      ok: result.ok === true,
-      output: tailAppend("", result.output || [
-        result.stderr,
-        result.stdout
-      ].filter(Boolean).join("\n")),
-      signal: result.signal,
-      timedOut: result.timedOut === true
-    };
-  } catch (error) {
-    return {
-      error,
-      ok: false,
-      output: normalizeAgentText(error?.message || error)
-    };
-  }
-}
-
 function codexAppServerEndpointForTarget(endpoint = "") {
   const normalizedEndpoint = normalizeAgentText(endpoint);
   if (!normalizedEndpoint) {
@@ -998,8 +426,8 @@ function codexAppServerEndpointForTarget(endpoint = "") {
 }
 
 function codexAppServerThreadRequestParams(params = {}, threadEnv = {}) {
-  const source = isPlainObject(params) ? params : {};
-  const config = isPlainObject(source.config) ? source.config : {};
+  const source = isRecord(params) ? params : {};
+  const config = isRecord(source.config) ? source.config : {};
   if (Object.hasOwn(config, "shell_environment_policy")) {
     return source;
   }
@@ -1071,13 +499,13 @@ async function sendCodexAppServerPrompt({
 function codexTurnInput(input = []) {
   const values = Array.isArray(input) ? input : [input];
   return values.map((item) => {
-    if (isPlainObject(item) && item.type === "localImage" && typeof item.path === "string") {
+    if (isRecord(item) && item.type === "localImage" && typeof item.path === "string") {
       return { type: "localImage", path: item.path };
     }
-    if (isPlainObject(item) && item.type === "image" && typeof item.url === "string") {
+    if (isRecord(item) && item.type === "image" && typeof item.url === "string") {
       return { type: "image", url: item.url };
     }
-    if (isPlainObject(item) && item.type === "text") {
+    if (isRecord(item) && item.type === "text") {
       return codexTextInput(item.text);
     }
     return codexTextInput(item);
@@ -1196,7 +624,7 @@ async function listBoundedCodexAppServerThreadIds({
         entryBytes = CODEX_APP_SERVER_THREAD_INVENTORY_MAX_ENTRY_BYTES + 1;
       }
       if (
-        !isPlainObject(entry) ||
+        !isRecord(entry) ||
         !threadId ||
         threadId.length > CODEX_APP_SERVER_THREAD_INVENTORY_ID_MAX_LENGTH ||
         codexAppServerTextHasControlCharacters(threadId) ||
@@ -1276,24 +704,15 @@ function normalizeAgentTurn(value = {}) {
   };
 }
 
-async function assertCodexAuthPreflightReady(options = {}, {
-  reason = "codex-auth-preflight", execution, credentials
-} = {}) {
-  const result = await runCodexAuthPreflight(options, execution);
-  if (result.ok && !codexAuthOutputRequiresReconnect(result.output)) {
-    return result;
-  }
-  const observed = normalizeAgentText(result.output || result.error?.message || "Codex auth preflight failed.");
-  if (codexAuthOutputRequiresReconnect(observed)) {
-    await credentials.markInvalid( {
-      reason
-    });
-    throw credentials.reconnectError({
-      modelProviderId: "",
-      observed
-    });
-  }
-  throw new Error(observed || "Codex auth preflight failed.");
+// The one reading of a sendTurn delivery. Its turn is already normalized; the
+// provider's own error stays on the raw native turn.
+function codexAppServerDeliveredTurn(delivery = {}) {
+  const turn = delivery?.turn || {};
+  return {
+    turnId: normalizeAgentText(turn.id),
+    status: normalizeAgentText(turn.status || turn.raw?.status),
+    error: codexAppServerErrorText(turn.raw?.error || turn.response?.turn?.error || turn.error)
+  };
 }
 
 export class CodexAppServerAgentProvider {
@@ -2523,7 +1942,7 @@ export class CodexAppServerAgentProvider {
     const includeHidden = params.includeHidden === true;
     const limit = normalizePositiveInteger(
       params.limit,
-      CODEX_APP_SERVER_MODEL_CATALOG_PAGE_LIMIT
+      { fallback: CODEX_APP_SERVER_MODEL_CATALOG_PAGE_LIMIT }
     );
     const boundedLimit = Math.min(limit, CODEX_APP_SERVER_MODEL_CATALOG_PAGE_LIMIT);
     let totalBytes = 0;
@@ -2562,7 +1981,7 @@ export class CodexAppServerAgentProvider {
         throw this.modelCatalogError("Codex model catalog exceeded its entry limit.");
       }
       for (const entry of response.data) {
-        if (!isPlainObject(entry)) {
+        if (!isRecord(entry)) {
           throw this.modelCatalogError("Codex model catalog contained an invalid entry.");
         }
         let entryBytes = 0;
@@ -2651,7 +2070,7 @@ export class CodexAppServerAgentProvider {
   }
 
   async writeHookTrustState(state = {}) {
-    if (!isPlainObject(state) || Object.keys(state).length === 0) {
+    if (!isRecord(state) || Object.keys(state).length === 0) {
       return null;
     }
     const client = await this.activeClient();
@@ -2860,11 +2279,9 @@ export class CodexAppServerAgentProvider {
 }
 
 export {
-  CODEX_APP_SERVER_INVALID_REQUEST_CODE, assertCodexAuthPreflightReady,
-  createCodexAppServerModelCatalogCache, codexAppServerProviderConnectionGeneration,
+  CODEX_APP_SERVER_INVALID_REQUEST_CODE,
   ensureCodexAppServerThread, codexApplicationToolConfiguration, assertCodexApplicationToolSchemaIdentity, sendCodexAppServerPrompt,
-  resumeExactCodexAppServerThread, startFreshCodexAppServerThread,
-  defineCodexRenewalThreadIds, codexRenewalThreadError,
+  codexAppServerDeliveredTurn,
   codexAppServerEndpointForTarget, codexAppServerRequestIsInvalid, codexAppServerThreadIsMissing,
   codexAppServerThreadHasReadableHistory, deleteCodexAppServerThread, deleteCodexAppServerHelperThread,
   inspectCodexAppServerMessageAdmission,