@opengeni/codex 0.2.15 → 0.2.16

package/dist/index.js

@@ -914,15 +914,90 @@ function parseCodexUsageHeaders(headers) {
     checkedAt: new Date(nowMs)
   };
 }
-async function emitRequestEvent(audit, event) {
-  await audit.ctx.onModelRequestEvent?.({
+function classifyCodexSseTerminal(ev) {
+  if (ev.type === "response.failed") {
+    return {
+      phase: "failed",
+      rawError: ev.response?.error,
+      fallbackCode: "response_failed",
+      fallbackMessage: "The Codex response failed"
+    };
+  }
+  if (ev.type === "error" || ev.type === "response.error") {
+    return {
+      phase: "failed",
+      rawError: ev.error ?? ev.response?.error ?? ev,
+      fallbackCode: "response_error",
+      fallbackMessage: "The Codex response stream reported an error"
+    };
+  }
+  if (ev.type === "response.incomplete") {
+    const details = ev.response?.incomplete_details;
+    const reason = details && typeof details === "object" ? details.reason : void 0;
+    return {
+      phase: "failed",
+      rawError: {
+        code: "response_incomplete",
+        message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
+      },
+      fallbackCode: "response_incomplete",
+      fallbackMessage: "The Codex response was incomplete"
+    };
+  }
+  if (ev.type !== "response.completed" && ev.type !== "response.done") {
+    return null;
+  }
+  if (!ev.response) {
+    return null;
+  }
+  const responseStatus = ev.response.status;
+  if (responseStatus !== void 0 && responseStatus !== "completed" || ev.response.error !== null && ev.response.error !== void 0) {
+    const incomplete = responseStatus === "incomplete";
+    return {
+      phase: "failed",
+      rawError: ev.response.error,
+      fallbackCode: incomplete ? "response_incomplete" : "response_failed",
+      fallbackMessage: incomplete ? "The Codex response was incomplete" : "The Codex response failed"
+    };
+  }
+  return { phase: "completed" };
+}
+function markSemanticTerminal(state, phase) {
+  if (state.phase === null) {
+    state.phase = phase;
+  }
+}
+function terminalOutcomeForPhase(phase) {
+  if (phase === "completed" || phase === "failed" || phase === "timed_out") {
+    return phase;
+  }
+  return null;
+}
+function requestEventFor(audit, event) {
+  return {
     requestId: audit.requestId,
     transportAttempt: audit.transportAttempt,
     ...audit.model ? { model: audit.model } : {},
-    durationMs: Math.max(0, Date.now() - audit.attemptStartedAt),
+    durationMs: Math.max(0, performance.now() - audit.attemptStartedAtMonotonic),
     timeoutPolicy: audit.policy,
     ...event
-  });
+  };
+}
+async function emitRequestEvent(audit, event) {
+  const terminalOutcome = terminalOutcomeForPhase(event.phase);
+  if (terminalOutcome !== null) {
+    if (audit.terminalOutcome !== null) {
+      return false;
+    }
+    audit.terminalOutcome = terminalOutcome;
+  }
+  const observed = requestEventFor(audit, event);
+  try {
+    audit.ctx.onModelRequestDiagnostic?.(observed);
+  } catch {
+  }
+  await audit.ctx.onModelRequestEvent?.(observed);
+  return true;
 }
 function providerRequestId(headers) {
   return headers.get("x-request-id") ?? headers.get("request-id") ?? void 0;
@@ -963,11 +1038,12 @@ async function fetchBeforeHeaders(base, input, init, audit) {
     externalSignal?.removeEventListener("abort", forwardAbort);
   }
 }
-async function observedResponse(res, audit, externalSignal) {
+async function observedResponse(res, audit, externalSignal, semanticTerminal) {
   const requestId = providerRequestId(res.headers);
   if (!res.body) {
+    if (semanticTerminal) markSemanticTerminal(semanticTerminal, "failed");
     await emitRequestEvent(audit, {
-      phase: res.ok ? "completed" : "failed",
+      phase: semanticTerminal?.phase ?? (res.ok ? "completed" : "failed"),
       responseObserved: true,
       status: res.status,
       ...requestId ? { providerRequestId: requestId } : {}
@@ -992,17 +1068,19 @@ async function observedResponse(res, audit, externalSignal) {
         if (terminal) return;
         terminal = true;
         clearTimers();
+        const semanticPhase = semanticTerminal?.phase;
+        const phase = semanticPhase ?? "timed_out";
         const error = new CodexResponseTimeoutError(klass, audit.requestId, true);
         void reader.cancel(error).catch(() => void 0);
         void emitRequestEvent(audit, {
-          phase: "timed_out",
+          phase,
           responseObserved: true,
-          timeoutClass: klass,
+          ...phase === "timed_out" ? { timeoutClass: klass } : {},
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
         }).then(
-          () => controller.error(error),
-          () => controller.error(error)
+          () => phase === "completed" ? controller.close() : controller.error(error),
+          () => phase === "completed" ? controller.close() : controller.error(error)
         );
       };
       armIdle = () => {
@@ -1022,13 +1100,13 @@ async function observedResponse(res, audit, externalSignal) {
         const reason = externalSignal?.reason ?? new DOMException("Aborted", "AbortError");
         void reader.cancel(reason).catch(() => void 0);
         void emitRequestEvent(audit, {
-          phase: "failed",
+          phase: semanticTerminal?.phase ?? "failed",
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
         }).then(
-          () => controller.error(reason),
-          () => controller.error(reason)
+          () => semanticTerminal?.phase === "completed" ? controller.close() : controller.error(reason),
+          () => semanticTerminal?.phase === "completed" ? controller.close() : controller.error(reason)
         );
       };
       if (externalSignal?.aborted) {
@@ -1047,12 +1125,19 @@ async function observedResponse(res, audit, externalSignal) {
         if (chunk.done) {
           terminal = true;
           clearTimers();
-          await emitRequestEvent(audit, {
-            phase: res.ok ? "completed" : "failed",
-            responseObserved: true,
-            status: res.status,
-            ...requestId ? { providerRequestId: requestId } : {}
-          });
+          if (semanticTerminal && semanticTerminal.phase === null) {
+            if (!semanticTerminal.deferTransportTerminal) {
+              markSemanticTerminal(semanticTerminal, "failed");
+            }
+          }
+          if (!semanticTerminal?.deferTransportTerminal || semanticTerminal.phase !== null) {
+            await emitRequestEvent(audit, {
+              phase: semanticTerminal?.phase ?? (res.ok ? "completed" : "failed"),
+              responseObserved: true,
+              status: res.status,
+              ...requestId ? { providerRequestId: requestId } : {}
+            });
+          }
           controller.close();
           return;
         }
@@ -1075,21 +1160,32 @@ async function observedResponse(res, audit, externalSignal) {
         if (terminal) return;
         terminal = true;
         clearTimers();
+        const semanticPhase = semanticTerminal?.phase;
+        if (semanticTerminal && semanticPhase === null) {
+          markSemanticTerminal(semanticTerminal, "failed");
+        }
         await emitRequestEvent(audit, {
-          phase: "failed",
+          phase: semanticPhase ?? "failed",
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
         });
-        controller.error(error);
+        if (semanticPhase === "completed") {
+          controller.close();
+        } else {
+          controller.error(error);
+        }
       }
     },
     async cancel(reason) {
       if (!terminal) {
         terminal = true;
         clearTimers();
+        if (semanticTerminal && semanticTerminal.phase === null) {
+          markSemanticTerminal(semanticTerminal, "failed");
+        }
         await emitRequestEvent(audit, {
-          phase: "failed",
+          phase: semanticTerminal?.phase ?? "failed",
           responseObserved: true,
           status: res.status,
           ...requestId ? { providerRequestId: requestId } : {}
@@ -1219,13 +1315,18 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
         transportAttempt,
         ...model ? { model } : {},
         logicalStartedAt,
-        attemptStartedAt: Date.now(),
-        policy
+        attemptStartedAtMonotonic: performance.now(),
+        policy,
+        terminalOutcome: null
       };
       await emitRequestEvent(audit, {
         phase: "started",
         responseObserved: false
       });
+      const semanticTerminal = {
+        phase: null,
+        deferTransportTerminal: !callerWantsStream
+      };
       try {
         res = await fetchBeforeHeaders(base, rewritten, nextInit, audit);
         const upstreamRequestId = providerRequestId(res.headers);
@@ -1235,8 +1336,7 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
           status: res.status,
           ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
         });
-        const observed = await observedResponse(res, audit, nextInit.signal);
-        res = observed;
+        res = await observedResponse(res, audit, nextInit.signal, semanticTerminal);
       } catch (error) {
         if (nextInit.signal?.aborted) {
           await emitRequestEvent(audit, {
@@ -1273,9 +1373,25 @@ function codexSubscriptionFetch(base = globalThis.fetch) {
         });
       }
       if (!res.ok) {
-        return await bufferCodexErrorResponse(res);
+        const buffered = await bufferCodexErrorResponse(res);
+        const upstreamRequestId = providerRequestId(res.headers);
+        markSemanticTerminal(semanticTerminal, "failed");
+        await emitRequestEvent(audit, {
+          phase: "failed",
+          responseObserved: true,
+          status: res.status,
+          ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+        }).catch(() => void 0);
+        return buffered;
+      }
+      if (callerWantsStream) {
+        res = validateCodexStream(res, (phase) => {
+          markSemanticTerminal(semanticTerminal, phase);
+        });
+      } else {
+        res = await sseToJsonResponse(res, audit, semanticTerminal);
       }
-      return callerWantsStream ? validateCodexStream(res) : await sseToJsonResponse(res);
+      return res;
     };
     try {
       let res = await attempt(await ctx.getToken(), 0);
@@ -1382,7 +1498,8 @@ async function readBoundedResponseText(response, maxBytes) {
   }
   return { text: parts.join(""), truncated };
 }
-async function sseToJsonResponse(res) {
+async function sseToJsonResponse(res, audit, semanticTerminal) {
+  const upstreamRequestId = providerRequestId(res.headers);
   const text = await res.text();
   let final = null;
   let terminalError = null;
@@ -1395,57 +1512,45 @@ async function sseToJsonResponse(res) {
       const ev = JSON.parse(data);
       if (ev.type === "response.output_item.done" && ev.item !== void 0) {
         items.push(ev.item);
-      } else if (ev.type === "response.failed") {
-        terminalError = codexSseFailureResponse(
-          res,
-          ev.response?.error,
-          "response_failed",
-          "The Codex response failed",
-          {
-            eventType: ev.type,
-            responseId: ev.response?.id,
-            responseStatus: ev.response?.status
-          }
-        );
-      } else if (ev.type === "error" || ev.type === "response.error") {
-        terminalError = codexSseFailureResponse(
-          res,
-          ev.error ?? ev.response?.error ?? ev,
-          "response_error",
-          "The Codex response stream reported an error",
-          {
-            eventType: ev.type,
-            responseId: ev.response?.id,
-            responseStatus: ev.response?.status
-          }
-        );
-      } else if (ev.type === "response.incomplete") {
-        const details = ev.response?.incomplete_details;
-        const reason = details && typeof details === "object" ? details.reason : void 0;
-        terminalError = codexSseFailureResponse(
-          res,
-          {
-            code: "response_incomplete",
-            message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
-          },
-          "response_incomplete",
-          "The Codex response was incomplete",
-          {
-            eventType: ev.type,
-            responseId: ev.response?.id,
-            responseStatus: ev.response?.status
-          }
-        );
-      } else if (ev.type === "response.completed" || ev.type === "response.done") {
-        final = ev.response ?? null;
+      } else {
+        const terminal = classifyCodexSseTerminal(ev);
+        if (terminal?.phase === "failed") {
+          terminalError = codexSseFailureResponse(
+            res,
+            terminal.rawError,
+            terminal.fallbackCode,
+            terminal.fallbackMessage,
+            {
+              eventType: ev.type,
+              responseId: ev.response?.id,
+              responseStatus: ev.response?.status
+            }
+          );
+        } else if (terminal?.phase === "completed") {
+          final = ev.response ?? null;
+        }
       }
     } catch {
     }
   }
   if (terminalError) {
+    markSemanticTerminal(semanticTerminal, "failed");
+    await emitRequestEvent(audit, {
+      phase: "failed",
+      responseObserved: true,
+      status: res.status,
+      ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+    });
     return terminalError;
   }
   if (!final) {
+    markSemanticTerminal(semanticTerminal, "failed");
+    await emitRequestEvent(audit, {
+      phase: "failed",
+      responseObserved: true,
+      status: res.status,
+      ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+    });
     return codexSseFailureResponse(
       res,
       null,
@@ -1461,6 +1566,13 @@ async function sseToJsonResponse(res) {
       `[codex-debug] sse->json items=${items.length} outputLen=${Array.isArray(final?.output) ? final.output.length : "?"}`
     );
   }
+  markSemanticTerminal(semanticTerminal, "completed");
+  await emitRequestEvent(audit, {
+    phase: "completed",
+    responseObserved: true,
+    status: res.status,
+    ...upstreamRequestId ? { providerRequestId: upstreamRequestId } : {}
+  });
   const headers = new Headers(res.headers);
   headers.set("content-type", "application/json");
   headers.delete("content-length");
@@ -1613,8 +1725,9 @@ function codexSseFailureError(source, rawError, fallbackCode, publicMessage, met
     codexSseFailureProjection(source, rawError, fallbackCode, publicMessage, metadata)
   );
 }
-function validateCodexStream(res) {
+function validateCodexStream(res, onSemanticTerminal) {
   if (!res.body) {
+    onSemanticTerminal?.("failed");
     const error = codexSseFailureError(
       res,
       null,
@@ -1644,7 +1757,7 @@ function validateCodexStream(res) {
       const block = buffer.slice(0, boundary.start);
       const separator = buffer.slice(boundary.start, boundary.end);
       buffer = buffer.slice(boundary.end);
-      successfulTerminalSeen ||= inspectCodexSseBlock(block, res);
+      successfulTerminalSeen ||= inspectCodexSseBlock(block, res, onSemanticTerminal);
       controller.enqueue(encoder.encode(`${block}${separator}`));
       boundary = findSseBlockBoundary(buffer, final);
     }
@@ -1658,7 +1771,7 @@ function validateCodexStream(res) {
       buffer += decoder.decode();
       emitCompleteBlocks(controller, true);
       if (buffer.length > 0) {
-        successfulTerminalSeen ||= inspectCodexSseBlock(buffer, res);
+        successfulTerminalSeen ||= inspectCodexSseBlock(buffer, res, onSemanticTerminal);
         controller.enqueue(encoder.encode(buffer));
         buffer = "";
       }
@@ -1708,7 +1821,7 @@ var CODEX_TERMINAL_TYPE_HINTS = [
   '"response.error"',
   '"error"'
 ];
-function inspectCodexSseBlock(block, source) {
+function inspectCodexSseBlock(block, source, onSemanticTerminal) {
   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]") {
@@ -1723,43 +1836,14 @@ function inspectCodexSseBlock(block, source) {
   } catch {
     return false;
   }
-  if (ev.type === "response.failed") {
-    throw codexSseFailureError(
-      source,
-      ev.response?.error,
-      "response_failed",
-      "The Codex response failed",
-      {
-        eventType: ev.type,
-        responseId: ev.response?.id,
-        responseStatus: ev.response?.status
-      }
-    );
-  }
-  if (ev.type === "error" || ev.type === "response.error") {
-    throw codexSseFailureError(
-      source,
-      ev.error ?? ev.response?.error ?? ev,
-      "response_error",
-      "The Codex response stream reported an error",
-      {
-        eventType: ev.type,
-        responseId: ev.response?.id,
-        responseStatus: ev.response?.status
-      }
-    );
-  }
-  if (ev.type === "response.incomplete") {
-    const details = ev.response?.incomplete_details;
-    const reason = details && typeof details === "object" ? details.reason : void 0;
+  const terminal = classifyCodexSseTerminal(ev);
+  if (terminal?.phase === "failed") {
+    onSemanticTerminal?.("failed");
     throw codexSseFailureError(
       source,
-      {
-        code: "response_incomplete",
-        message: typeof reason === "string" && reason.length > 0 ? `The Codex response was incomplete (${reason})` : "The Codex response was incomplete"
-      },
-      "response_incomplete",
-      "The Codex response was incomplete",
+      terminal.rawError,
+      terminal.fallbackCode,
+      terminal.fallbackMessage,
       {
         eventType: ev.type,
         responseId: ev.response?.id,
@@ -1767,20 +1851,8 @@ function inspectCodexSseBlock(block, source) {
       }
     );
   }
-  if ((ev.type === "response.completed" || ev.type === "response.done") && ev.response) {
-    if (ev.response.status !== void 0 && ev.response.status !== "completed" || ev.response.error !== null && ev.response.error !== void 0) {
-      throw codexSseFailureError(
-        source,
-        ev.response.error,
-        ev.response.status === "incomplete" ? "response_incomplete" : "response_failed",
-        ev.response.status === "incomplete" ? "The Codex response was incomplete" : "The Codex response failed",
-        {
-          eventType: ev.type,
-          responseId: ev.response.id,
-          responseStatus: ev.response.status
-        }
-      );
-    }
+  if (terminal?.phase === "completed") {
+    onSemanticTerminal?.("completed");
     return true;
   }
   return false;