@opengeni/codex 0.2.23 → 0.2.24-canary.35585322809001

package/dist/fetch.d.ts

@@ -21,6 +21,8 @@ export type CodexEncryptedArtifactRejection = {
     status: 400;
     kind: "encrypted_content_rejected";
 };
+/** Exact Codex `error.code` for an opaque artifact the backend can no longer use. */
+export declare const CODEX_ENCRYPTED_CONTENT_REJECTION_CODE = "invalid_encrypted_content";
 /**
  * Classify only the provider's definitive request rejection for an opaque
  * reasoning artifact that it can no longer decrypt/parse. A Codex transport

package/dist/index.d.ts

@@ -15,3 +15,4 @@ export * from "./opaque-artifact.js";
 export * from "./images.js";
 export * from "./realtime.js";
 export * from "./realtime-v3.js";
+export * from "./reasoning-configuration.js";

package/dist/index.js

@@ -814,6 +814,28 @@ function isPreHeadersTimeoutError(error) {
 // src/fetch.ts
 import { randomUUID } from "crypto";
 
+// src/meaningful-output.ts
+function hasMeaningfulCodexOutput(output) {
+  if (!Array.isArray(output)) return false;
+  return output.some((value) => {
+    if (!value || typeof value !== "object") return false;
+    const item = value;
+    if (item.status !== void 0 && item.status !== "completed") return false;
+    if (item.type === "message" && item.role === "assistant" && Array.isArray(item.content)) {
+      return item.content.some((part) => {
+        if (!part || typeof part !== "object") return false;
+        const content = part;
+        return content.type === "output_text" && typeof content.text === "string" && content.text.trim().length > 0;
+      });
+    }
+    if (item.type === "function_call" || item.type === "custom_tool_call") {
+      const payload = item.type === "function_call" ? item.arguments : item.input;
+      return typeof item.name === "string" && item.name.trim().length > 0 && typeof item.call_id === "string" && item.call_id.length > 0 && typeof payload === "string" && payload.trim().length > 0;
+    }
+    return item.type === "image_generation_call" && typeof item.result === "string" && item.result.length > 0;
+  });
+}
+
 // src/opaque-artifact.ts
 import { createHash } from "crypto";
 function opaqueProviderArtifactFingerprint(item) {
@@ -865,6 +887,7 @@ function isCodexTransportError(error) {
   }
   return false;
 }
+var CODEX_ENCRYPTED_CONTENT_REJECTION_CODE = "invalid_encrypted_content";
 function classifyCodexEncryptedArtifactRejection(error) {
   if (!isCodexTransportError(error)) return null;
   let current = error;
@@ -872,6 +895,10 @@ function classifyCodexEncryptedArtifactRejection(error) {
     const value = current;
     const body = value.error && typeof value.error === "object" ? value.error : null;
     const status = Number(value.status ?? body?.status);
+    const exactCode = typeof body?.code === "string" ? body.code : typeof value.code === "string" ? value.code : "";
+    if (status === 400 && exactCode === CODEX_ENCRYPTED_CONTENT_REJECTION_CODE) {
+      return { status: 400, kind: "encrypted_content_rejected" };
+    }
     const message = [
       typeof value.message === "string" ? value.message : "",
       typeof body?.message === "string" ? body.message : "",
@@ -986,6 +1013,9 @@ function markSemanticTerminal(state, phase) {
     state.phase = phase;
   }
 }
+function semanticCompletionEvidence(state) {
+  return state?.phase === "completed" ? { meaningfulOutput: state.meaningfulOutput === true } : {};
+}
 function terminalOutcomeForPhase(phase) {
   if (phase === "completed" || phase === "failed" || phase === "timed_out") {
     return phase;
@@ -1063,6 +1093,7 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
     if (semanticTerminal) markSemanticTerminal(semanticTerminal, "failed");
     await emitRequestEvent(audit, {
       phase: semanticTerminal?.phase ?? (res.ok ? "completed" : "failed"),
+      ...semanticCompletionEvidence(semanticTerminal),
       responseObserved: true,
       status: res.status,
       ...requestId ? { providerRequestId: requestId } : {}
@@ -1093,6 +1124,7 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
         void reader.cancel(error).catch(() => void 0);
         void emitRequestEvent(audit, {
           phase,
+          ...semanticCompletionEvidence(semanticTerminal),
           responseObserved: true,
           ...phase === "timed_out" ? { timeoutClass: klass } : {},
           status: res.status,
@@ -1120,6 +1152,7 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
         void reader.cancel(reason).catch(() => void 0);
         void emitRequestEvent(audit, {
           phase: semanticTerminal?.phase ?? "failed",
+          ...semanticCompletionEvidence(semanticTerminal),
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
@@ -1144,14 +1177,10 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
         if (chunk.done) {
           terminal = true;
           clearTimers();
-          if (semanticTerminal && semanticTerminal.phase === null) {
-            if (!semanticTerminal.deferTransportTerminal) {
-              markSemanticTerminal(semanticTerminal, "failed");
-            }
-          }
-          if (!semanticTerminal?.deferTransportTerminal || semanticTerminal.phase !== null) {
+          if (!semanticTerminal || semanticTerminal.phase !== null) {
             await emitRequestEvent(audit, {
               phase: semanticTerminal?.phase ?? (res.ok ? "completed" : "failed"),
+              ...semanticCompletionEvidence(semanticTerminal),
               responseObserved: true,
               status: res.status,
               ...requestId ? { providerRequestId: requestId } : {}
@@ -1185,6 +1214,7 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
         }
         await emitRequestEvent(audit, {
           phase: semanticPhase ?? "failed",
+          ...semanticCompletionEvidence(semanticTerminal),
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
@@ -1205,6 +1235,7 @@ async function observedResponse(res, audit, externalSignal, semanticTerminal) {
         }
         await emitRequestEvent(audit, {
           phase: semanticTerminal?.phase ?? "failed",
+          ...semanticCompletionEvidence(semanticTerminal),
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
@@ -1348,8 +1379,7 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
         responseObserved: false
       });
       const semanticTerminal = {
-        phase: null,
-        deferTransportTerminal: !callerWantsStream
+        phase: null
       };
       try {
         await ctx.beforeProviderDispatch?.();
@@ -1410,9 +1440,23 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
         return buffered;
       }
       if (callerWantsStream) {
-        res = validateCodexStream(res, (phase) => {
-          markSemanticTerminal(semanticTerminal, phase);
-        });
+        res = validateCodexStream(
+          res,
+          (phase, meaningfulOutput) => {
+            markSemanticTerminal(semanticTerminal, phase);
+            semanticTerminal.meaningfulOutput = meaningfulOutput === true;
+          },
+          async () => {
+            const upstreamRequestId = providerRequestId(res.headers);
+            await emitRequestEvent(audit, {
+              phase: semanticTerminal.phase ?? "failed",
+              ...semanticCompletionEvidence(semanticTerminal),
+              responseObserved: true,
+              status: res.status,
+              ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+            });
+          }
+        );
       } else {
         res = await sseToJsonResponse(res, audit, semanticTerminal);
       }
@@ -1596,6 +1640,7 @@ async function sseToJsonResponse(res, audit, semanticTerminal) {
   markSemanticTerminal(semanticTerminal, "completed");
   await emitRequestEvent(audit, {
     phase: "completed",
+    meaningfulOutput: hasMeaningfulCodexOutput(final?.output),
     responseObserved: true,
     status: res.status,
     ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
@@ -1752,7 +1797,7 @@ function codexSseFailureError(source, rawError, fallbackCode, publicMessage, met
     codexSseFailureProjection(source, rawError, fallbackCode, publicMessage, metadata)
   );
 }
-function validateCodexStream(res, onSemanticTerminal) {
+function validateCodexStream(res, onSemanticTerminal, onParsedEof) {
   if (!res.body) {
     onSemanticTerminal?.("failed");
     const error = codexSseFailureError(
@@ -1778,13 +1823,18 @@ function validateCodexStream(res, onSemanticTerminal) {
   const encoder = new TextEncoder();
   let buffer = "";
   let successfulTerminalSeen = false;
+  let meaningfulOutput = false;
+  const observeOutput = (output) => {
+    meaningfulOutput ||= hasMeaningfulCodexOutput(output);
+  };
+  const observeTerminal = (phase) => onSemanticTerminal?.(phase, phase === "completed" && meaningfulOutput);
   const emitCompleteBlocks = (controller, final) => {
     let boundary = findSseBlockBoundary(buffer, final);
     while (boundary) {
       const block = buffer.slice(0, boundary.start);
       const separator = buffer.slice(boundary.start, boundary.end);
       buffer = buffer.slice(boundary.end);
-      successfulTerminalSeen ||= inspectCodexSseBlock(block, res, onSemanticTerminal);
+      successfulTerminalSeen ||= inspectCodexSseBlock(block, res, observeTerminal, observeOutput);
       controller.enqueue(encoder.encode(`${block}${separator}`));
       boundary = findSseBlockBoundary(buffer, final);
     }
@@ -1794,21 +1844,31 @@ function validateCodexStream(res, onSemanticTerminal) {
       buffer += decoder.decode(chunk, { stream: true });
       emitCompleteBlocks(controller, false);
     },
-    flush(controller) {
-      buffer += decoder.decode();
-      emitCompleteBlocks(controller, true);
-      if (buffer.length > 0) {
-        successfulTerminalSeen ||= inspectCodexSseBlock(buffer, res, onSemanticTerminal);
-        controller.enqueue(encoder.encode(buffer));
-        buffer = "";
-      }
-      if (!successfulTerminalSeen) {
-        throw codexSseFailureError(
-          res,
-          null,
-          "invalid_sse_terminal",
-          "The Codex response stream ended without a terminal response"
-        );
+    async flush(controller) {
+      try {
+        buffer += decoder.decode();
+        emitCompleteBlocks(controller, true);
+        if (buffer.length > 0) {
+          successfulTerminalSeen ||= inspectCodexSseBlock(
+            buffer,
+            res,
+            observeTerminal,
+            observeOutput
+          );
+          controller.enqueue(encoder.encode(buffer));
+          buffer = "";
+        }
+        if (!successfulTerminalSeen) {
+          observeTerminal("failed");
+          throw codexSseFailureError(
+            res,
+            null,
+            "invalid_sse_terminal",
+            "The Codex response stream ended without a terminal response"
+          );
+        }
+      } finally {
+        await onParsedEof?.();
       }
     }
   });
@@ -1848,13 +1908,13 @@ var CODEX_TERMINAL_TYPE_HINTS = [
   '"response.error"',
   '"error"'
 ];
-function inspectCodexSseBlock(block, source, onSemanticTerminal) {
+function inspectCodexSseBlock(block, source, onSemanticTerminal, onOutput) {
   const lines = block.split(/\r\n|\r|\n/);
   const dataStr = lines.filter((l) => l.startsWith("data:")).map((l) => l.slice(5).trim()).join("\n");
   if (!dataStr || dataStr === "[DONE]") {
     return false;
   }
-  if (!CODEX_TERMINAL_TYPE_HINTS.some((terminalType) => dataStr.includes(terminalType))) {
+  if (!dataStr.includes('"response.output_item.done"') && !CODEX_TERMINAL_TYPE_HINTS.some((terminalType) => dataStr.includes(terminalType))) {
     return false;
   }
   let ev;
@@ -1864,6 +1924,7 @@ function inspectCodexSseBlock(block, source, onSemanticTerminal) {
     return false;
   }
   const terminal = classifyCodexSseTerminal(ev);
+  if (ev.type === "response.output_item.done") onOutput?.([ev.item]);
   if (terminal?.phase === "failed") {
     onSemanticTerminal?.("failed");
     throw codexSseFailureError(
@@ -1879,6 +1940,7 @@ function inspectCodexSseBlock(block, source, onSemanticTerminal) {
     );
   }
   if (terminal?.phase === "completed") {
+    onOutput?.(ev.response?.output);
     onSemanticTerminal?.("completed");
     return true;
   }
@@ -2996,6 +3058,58 @@ async function readBoundedSdp(response) {
     );
   }
 }
+
+// src/reasoning-configuration.ts
+var REASONING_CONFIGURATION_FIELD = "opengeniReasoningConfiguration";
+var efforts = /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]);
+function supportsReasoningConfiguration(model, effort) {
+  return model === "gpt-6-astra" && efforts.has(effort);
+}
+function readReasoningConfiguration(item) {
+  const state = item[REASONING_CONFIGURATION_FIELD];
+  if (!state || state.version !== 1 || !efforts.has(state.baselineEffort) || !efforts.has(state.effort) || typeof state.turnId !== "string")
+    return null;
+  const data = item.providerData;
+  if (item.type !== "unknown" || data?.type !== "configuration_update" || data.reasoning?.effort !== state.effort)
+    return null;
+  return state;
+}
+function reasoningConfigurationItem(state) {
+  return {
+    type: "unknown",
+    providerData: { type: "configuration_update", reasoning: { effort: state.effort } },
+    [REASONING_CONFIGURATION_FIELD]: state
+  };
+}
+function latestReasoningConfiguration(items) {
+  for (let i = items.length - 1; i >= 0; i--) {
+    const state = readReasoningConfiguration(items[i]);
+    if (state) return state;
+  }
+  return null;
+}
+function isReasoningConfigurationUpdate(item) {
+  return item.type === "configuration_update" || item.type === "unknown" && item.providerData?.type === "configuration_update";
+}
+function projectReasoningConfigurations(items, enabled) {
+  const projected = [];
+  for (const item of items) {
+    if (!isReasoningConfigurationUpdate(item)) {
+      projected.push(item);
+      continue;
+    }
+    if (!enabled) continue;
+    if (projected.length && isReasoningConfigurationUpdate(projected[projected.length - 1]))
+      projected.pop();
+    projected.push(
+      item.type === "unknown" ? { type: "unknown", providerData: item.providerData } : {
+        type: "unknown",
+        providerData: { type: "configuration_update", reasoning: item.reasoning }
+      }
+    );
+  }
+  return projected;
+}
 export {
   CODEX_APPS_MCP_SERVER_ID,
   CODEX_APPS_MCP_SERVER_NAME,
@@ -3009,6 +3123,7 @@ export {
   CODEX_DEVICE_REDIRECT_URI,
   CODEX_DEVICE_VERIFICATION_URL,
   CODEX_EFFECTIVE_CONTEXT_WINDOW_PERCENT,
+  CODEX_ENCRYPTED_CONTENT_REJECTION_CODE,
   CODEX_FALLBACK_MODEL_SLUGS,
   CODEX_FIVE_HOUR_WINDOW_SECONDS,
   CODEX_ID_TOKEN_AUTH_CLAIM,
@@ -3070,6 +3185,7 @@ export {
   DEFAULT_MODEL_TOOL_OUTPUT_TRUNCATION_TOKENS,
   MODEL_TOOL_OUTPUT_OPAQUE_PAYLOAD_MAX_BYTES,
   MODEL_TOOL_OUTPUT_OVERSIZED_IMAGE_CARD_DATA_URL,
+  REASONING_CONFIGURATION_FIELD,
   ToolNameMapper,
   accessTokenExpiry,
   approximateTokenCount,
@@ -3101,6 +3217,8 @@ export {
   isCodexBilledModel,
   isCodexTransportError,
   isPreHeadersTimeoutError,
+  isReasoningConfigurationUpdate,
+  latestReasoningConfiguration,
   modelToolOutputSerializationBudgetTokens,
   normalizeCodexRequestBody,
   normalizeCodexUsage,
@@ -3115,6 +3233,9 @@ export {
   parseCodexUsageHeaders,
   parseIdToken,
   pollDeviceCode,
+  projectReasoningConfigurations,
+  readReasoningConfiguration,
+  reasoningConfigurationItem,
   refreshCodexToken,
   remapToolCallRequestBody,
   resolveCodexResponseTimeoutPolicy,
@@ -3122,6 +3243,7 @@ export {
   sanitizeMcpSseBody,
   selectCodexCredentialId,
   startDeviceCode,
+  supportsReasoningConfiguration,
   truncateMiddleWithTokenBudget,
   withCodexRequestOverrides
 };