@omnicross/core 0.1.10 → 0.2.1

package/dist/{chunk-HKB656B4.js → chunk-EUZRH544.js}

@@ -1,3 +1,6 @@
+import {
+  convertOpenAIStreamToAnthropic
+} from "./chunk-LFEH7CEO.js";
 import {
   anthropicUsageToChatUsage
 } from "./chunk-FU7EAR73.js";
@@ -9,8 +12,9 @@ import {
 import {
   extractReasoningIntent,
   normalizeThinkLevel,
+  recordDroppedField,
   resolveReasoningPlan
-} from "./chunk-N2EIM2XJ.js";
+} from "./chunk-ZLNHPUFA.js";
 
 // src/transformer/transformers/AnthropicToolHandling.ts
 function isServerSideTool(tool) {
@@ -155,6 +159,14 @@ function buildAnthropicRequestBody(request, provider) {
   if (request.temperature !== void 0) {
     body.temperature = request.temperature;
   }
+  if (request.stop !== void 0 && request.stop.length > 0) {
+    body.stop_sequences = request.stop;
+  }
+  if (request.top_p !== void 0) body.top_p = request.top_p;
+  if (request.top_k !== void 0) body.top_k = request.top_k;
+  if (request.metadata_user_id !== void 0) {
+    body.metadata = { user_id: request.metadata_user_id };
+  }
   if (systemContent !== void 0) {
     body.system = systemContent;
   }
@@ -325,6 +337,7 @@ function convertOpenAIResponseToAnthropic(openaiResponse) {
 function transformAnthropicRequestToUnified(request) {
   const anthropicRequest = request;
   const messages = [];
+  let redactedSeen = false;
   if (anthropicRequest.system) {
     if (typeof anthropicRequest.system === "string") {
       messages.push({
@@ -419,15 +432,40 @@ function transformAnthropicRequestToUnified(request) {
             }
           }));
         }
-        const thinkingPart = msg.content.find(
-          (c) => c.type === "thinking"
-        );
-        if (thinkingPart?.thinking) {
+        let thinkingText = "";
+        let firstSignature;
+        let sawRedacted = false;
+        for (const block of msg.content) {
+          if (block.type === "thinking") {
+            const t = block.thinking;
+            if (typeof t === "string" && t.length > 0) {
+              if (thinkingText.length > 0) thinkingText += "\n";
+              thinkingText += t;
+            }
+            const signature = block.signature;
+            if (signature) {
+              if (firstSignature === void 0) {
+                firstSignature = signature;
+              } else if (typeof t === "string" && t.length > 0) {
+                thinkingText += `
+[signature: ${signature}]`;
+              }
+            }
+          } else if (block.type === "redacted_thinking") {
+            sawRedacted = true;
+            if (thinkingText.length > 0) thinkingText += "\n";
+            thinkingText += "[redacted thinking omitted]";
+          }
+        }
+        if (thinkingText.length > 0) {
           assistantMessage.thinking = {
-            content: thinkingPart.thinking,
-            signature: thinkingPart.signature
+            content: thinkingText,
+            signature: firstSignature
           };
         }
+        if (sawRedacted) {
+          redactedSeen = true;
+        }
         messages.push(assistantMessage);
       }
     }
@@ -443,6 +481,16 @@ function transformAnthropicRequestToUnified(request) {
     stream: anthropicRequest.stream,
     tools: functionTools?.length ? functionTools : void 0
   };
+  const raw = anthropicRequest;
+  if (Array.isArray(raw.stop_sequences)) {
+    result.stop = raw.stop_sequences.filter((s) => typeof s === "string");
+  }
+  if (typeof raw.top_p === "number") result.top_p = raw.top_p;
+  if (typeof raw.top_k === "number") result.top_k = raw.top_k;
+  if (typeof raw.metadata?.user_id === "string") result.metadata_user_id = raw.metadata.user_id;
+  if (redactedSeen) {
+    recordDroppedField(result, "redacted_thinking", "unified");
+  }
   if (serverSideTools.length > 0) {
     result._serverSideTools = serverSideTools;
   }
@@ -644,286 +692,6 @@ ${formatted}` },
   });
 }
 
-// src/transformer/transformers/AnthropicOpenAIToAnthropicStream.ts
-function convertOpenAIStreamToAnthropic(openaiStream, _context, logger) {
-  const decoder = new TextDecoder();
-  const encoder = new TextEncoder();
-  let hasStarted = false;
-  let hasTextContentStarted = false;
-  let isThinkingStarted = false;
-  let contentIndex = 0;
-  let currentContentBlockIndex = -1;
-  const toolCallIndexToContentBlockIndex = /* @__PURE__ */ new Map();
-  return new ReadableStream({
-    start: async (controller) => {
-      const reader = openaiStream.getReader();
-      let buffer = "";
-      const messageId = `msg_${Date.now()}`;
-      let model = "unknown";
-      let isClosed = false;
-      let stopReasonDelta = null;
-      const safeEnqueue = (data) => {
-        if (!isClosed) {
-          try {
-            controller.enqueue(encoder.encode(data));
-          } catch (_e) {
-            isClosed = true;
-          }
-        }
-      };
-      const assignContentBlockIndex = () => {
-        return contentIndex++;
-      };
-      const safeClose = () => {
-        if (isClosed) return;
-        if (currentContentBlockIndex >= 0) {
-          safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-            type: "content_block_stop",
-            index: currentContentBlockIndex
-          })}
-
-`);
-        }
-        if (stopReasonDelta) {
-          safeEnqueue(`event: message_delta
-data: ${JSON.stringify(stopReasonDelta)}
-
-`);
-        } else {
-          safeEnqueue(`event: message_delta
-data: ${JSON.stringify({
-            type: "message_delta",
-            delta: { stop_reason: "end_turn", stop_sequence: null },
-            usage: { input_tokens: 0, output_tokens: 0 }
-          })}
-
-`);
-        }
-        safeEnqueue(`event: message_stop
-data: ${JSON.stringify({ type: "message_stop" })}
-
-`);
-        try {
-          controller.close();
-        } catch (_e) {
-        }
-        isClosed = true;
-      };
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (isClosed) break;
-            if (!line.startsWith("data:")) continue;
-            const data = line.slice(5).trim();
-            if (data === "[DONE]") continue;
-            try {
-              const chunk = JSON.parse(data);
-              if (chunk.error) {
-                safeEnqueue(`event: error
-data: ${JSON.stringify({
-                  type: "error",
-                  message: { type: "api_error", message: JSON.stringify(chunk.error) }
-                })}
-
-`);
-                continue;
-              }
-              model = chunk.model || model;
-              if (!hasStarted) {
-                hasStarted = true;
-                safeEnqueue(`event: message_start
-data: ${JSON.stringify({
-                  type: "message_start",
-                  message: {
-                    id: messageId,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model,
-                    stop_reason: null,
-                    stop_sequence: null,
-                    usage: { input_tokens: 0, output_tokens: 0 }
-                  }
-                })}
-
-`);
-              }
-              const choice = chunk.choices?.[0];
-              if (!choice) continue;
-              if (chunk.usage) {
-                stopReasonDelta = {
-                  type: "message_delta",
-                  delta: { stop_reason: "end_turn", stop_sequence: null },
-                  usage: {
-                    input_tokens: (chunk.usage.prompt_tokens || 0) - (chunk.usage.prompt_tokens_details?.cached_tokens || 0),
-                    output_tokens: chunk.usage.completion_tokens || 0,
-                    cache_read_input_tokens: chunk.usage.prompt_tokens_details?.cached_tokens || 0
-                  }
-                };
-              }
-              if (choice.delta?.thinking) {
-                if (!isThinkingStarted) {
-                  const thinkingBlockIndex = assignContentBlockIndex();
-                  safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: thinkingBlockIndex,
-                    content_block: { type: "thinking", thinking: "" }
-                  })}
-
-`);
-                  currentContentBlockIndex = thinkingBlockIndex;
-                  isThinkingStarted = true;
-                }
-                if (choice.delta.thinking.signature) {
-                  safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: currentContentBlockIndex,
-                    delta: { type: "signature_delta", signature: choice.delta.thinking.signature }
-                  })}
-
-`);
-                  safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                    type: "content_block_stop",
-                    index: currentContentBlockIndex
-                  })}
-
-`);
-                  currentContentBlockIndex = -1;
-                } else if (choice.delta.thinking.content) {
-                  safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: currentContentBlockIndex,
-                    delta: { type: "thinking_delta", thinking: choice.delta.thinking.content }
-                  })}
-
-`);
-                }
-              }
-              if (choice.delta?.content) {
-                if (!hasTextContentStarted) {
-                  if (currentContentBlockIndex >= 0 && isThinkingStarted) {
-                    safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                      type: "content_block_stop",
-                      index: currentContentBlockIndex
-                    })}
-
-`);
-                  }
-                  hasTextContentStarted = true;
-                  const textBlockIndex = assignContentBlockIndex();
-                  safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: textBlockIndex,
-                    content_block: { type: "text", text: "" }
-                  })}
-
-`);
-                  currentContentBlockIndex = textBlockIndex;
-                }
-                safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                  type: "content_block_delta",
-                  index: currentContentBlockIndex,
-                  delta: { type: "text_delta", text: choice.delta.content }
-                })}
-
-`);
-              }
-              if (choice.delta?.tool_calls) {
-                for (const toolCall of choice.delta.tool_calls) {
-                  const toolCallIndex = toolCall.index ?? 0;
-                  if (!toolCallIndexToContentBlockIndex.has(toolCallIndex)) {
-                    if (currentContentBlockIndex >= 0) {
-                      safeEnqueue(`event: content_block_stop
-data: ${JSON.stringify({
-                        type: "content_block_stop",
-                        index: currentContentBlockIndex
-                      })}
-
-`);
-                      hasTextContentStarted = false;
-                    }
-                    const newBlockIndex = assignContentBlockIndex();
-                    toolCallIndexToContentBlockIndex.set(toolCallIndex, newBlockIndex);
-                    safeEnqueue(`event: content_block_start
-data: ${JSON.stringify({
-                      type: "content_block_start",
-                      index: newBlockIndex,
-                      content_block: {
-                        type: "tool_use",
-                        id: toolCall.id || `call_${Date.now()}_${toolCallIndex}`,
-                        name: toolCall.function?.name || `tool_${toolCallIndex}`,
-                        input: {}
-                      }
-                    })}
-
-`);
-                    currentContentBlockIndex = newBlockIndex;
-                  }
-                  if (toolCall.function?.arguments) {
-                    const blockIndex = toolCallIndexToContentBlockIndex.get(toolCallIndex);
-                    if (blockIndex !== void 0) {
-                      safeEnqueue(`event: content_block_delta
-data: ${JSON.stringify({
-                        type: "content_block_delta",
-                        index: blockIndex,
-                        delta: { type: "input_json_delta", partial_json: toolCall.function.arguments }
-                      })}
-
-`);
-                    }
-                  }
-                }
-              }
-              if (choice.finish_reason) {
-                const stopReasonMapping = {
-                  stop: "end_turn",
-                  length: "max_tokens",
-                  tool_calls: "tool_use",
-                  content_filter: "stop_sequence"
-                };
-                stopReasonDelta = {
-                  type: "message_delta",
-                  delta: {
-                    stop_reason: stopReasonMapping[choice.finish_reason] || "end_turn",
-                    stop_sequence: null
-                  },
-                  usage: {
-                    input_tokens: (chunk.usage?.prompt_tokens || 0) - (chunk.usage?.prompt_tokens_details?.cached_tokens || 0),
-                    output_tokens: chunk.usage?.completion_tokens || 0,
-                    cache_read_input_tokens: chunk.usage?.prompt_tokens_details?.cached_tokens || 0
-                  }
-                };
-              }
-            } catch (e) {
-              logger?.error("Error parsing stream chunk:", e);
-            }
-          }
-        }
-      } catch (e) {
-        if (!isClosed) {
-          controller.error(e);
-        }
-      } finally {
-        safeClose();
-        reader.releaseLock();
-      }
-    }
-  });
-}
-
 // src/transformer/transformers/AnthropicTransformer.ts
 var AnthropicTransformer = class {
   static TransformerName = "anthropic";

package/dist/{chunk-WNKWAEUR.js → chunk-EYGBM2VC.js}

@@ -30,6 +30,7 @@ var TransformerChainExecutor = class {
       providerName: provider.name
     };
     let requestBody = request;
+    let endpointRequest;
     let config = {};
     let bypass = false;
     bypass = this.shouldBypassTransformers(
@@ -60,6 +61,7 @@ var TransformerChainExecutor = class {
         this.logger.error(`transformRequestOut error: ${this.getErrorMessage(error)}`);
         throw error;
       }
+      endpointRequest = requestBody;
     }
     if (!bypass && chain.providerTransformers.length > 0) {
       this.logger.debug(`Executing ${chain.providerTransformers.length} provider transformers`);
@@ -118,7 +120,7 @@ var TransformerChainExecutor = class {
         true
       );
     }
-    return { requestBody, config, bypass };
+    return { requestBody, endpointRequest, config, bypass };
   }
   /**
    * Execute the response transformation chain

package/dist/{chunk-UWDW6PN3.cjs → chunk-FX325I5Q.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkFCR77GYMcjs = require('./chunk-FCR77GYM.cjs');
 
+var _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
 
 
-var _chunkAEOZIDEBcjs = require('./chunk-AEOZIDEB.cjs');
+var _chunkHCOQQAZEcjs = require('./chunk-HCOQQAZE.cjs');
 
 
 var _chunkXSVNC2UDcjs = require('./chunk-XSVNC2UD.cjs');
@@ -195,24 +195,35 @@ function resolveClientIp(req, trustForwardedFor) {
   }
   return _nullishCoalesce(_optionalChain([req, 'access', _8 => _8.socket, 'optionalAccess', _9 => _9.remoteAddress]), () => ( void 0));
 }
-function beginAuditCapture(req, res, now) {
+function beginAuditCapture(req, res, now, options) {
   const config = _chunkAEOZIDEBcjs.getAuditCaptureConfig.call(void 0, );
   if (!config) return null;
+  const captureBodies = config.captureBodies;
   let requestBody;
   const responseChunks = [];
   let responseBytes = 0;
   let responseTruncated = false;
+  let bodiesSuppressed = _optionalChain([options, 'optionalAccess', _10 => _10.suppressBodies]) === true;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
-      if (config.captureBodies) {
-        requestBody = truncateToBytes(_chunkFCR77GYMcjs.redactAuditText.call(void 0, raw), config.maxBodyBytes);
+      if (captureBodies && !bodiesSuppressed) {
+        requestBody = truncateToBytes(_chunkHCOQQAZEcjs.redactAuditText.call(void 0, raw), config.maxBodyBytes);
       }
+    },
+    suppressBodies() {
+      if (bodiesSuppressed) return;
+      bodiesSuppressed = true;
+      requestBody = void 0;
+      responseChunks.length = 0;
+      responseBytes = 0;
+      responseTruncated = false;
     }
   };
-  if (config.captureBodies) {
+  if (captureBodies && !bodiesSuppressed) {
     installResponseCapture(res, {
       push(chunk) {
+        if (bodiesSuppressed) return;
         if (config.maxBodyBytes < 0) {
           responseChunks.push(chunk);
           responseBytes += chunk.length;
@@ -261,9 +272,9 @@ function beginAuditCapture(req, res, now) {
         if (!record.model && usage.model) record.model = usage.model;
         if (!record.provider && usage.provider) record.provider = usage.provider;
       }
-      if (ctx.error) record.error = _chunkFCR77GYMcjs.redactAuditText.call(void 0, ctx.error);
+      if (ctx.error) record.error = _chunkHCOQQAZEcjs.redactAuditText.call(void 0, ctx.error);
       if (ctx.sessionKey) record.sessionKey = ctx.sessionKey;
-      if (config.captureBodies) {
+      if (captureBodies && !bodiesSuppressed) {
         if (requestBody != null && requestBody.length > 0) {
           record.requestBody = requestBody;
         }
@@ -271,7 +282,7 @@ function beginAuditCapture(req, res, now) {
           const captured = Buffer.concat(responseChunks, responseBytes);
           const decoded = decodeCapturedBody(captured, responseTruncated);
           const body = config.compactStreamingBodies ? compactSseBody(decoded) : decoded;
-          record.responseBody = truncateToBytes(_chunkFCR77GYMcjs.redactAuditText.call(void 0, body), config.maxBodyBytes);
+          record.responseBody = truncateToBytes(_chunkHCOQQAZEcjs.redactAuditText.call(void 0, body), config.maxBodyBytes);
         }
         if (record.requestBody !== void 0 || record.responseBody !== void 0) {
           record.hasBody = true;

package/dist/chunk-G4CZIUIB.cjs

@@ -0,0 +1,200 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class; var _class2; var _class3;// src/openai-operation/openAIOperation.ts
+var OPERATIONS = {
+  "chat.completions.create": {
+    id: "chat.completions.create",
+    policyFamily: "chat",
+    routeFamily: "chat",
+    owner: "builtin",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "responses.create": {
+    id: "responses.create",
+    policyFamily: "responses",
+    routeFamily: "responses",
+    owner: "builtin",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "responses.compact": {
+    id: "responses.compact",
+    policyFamily: "responses",
+    routeFamily: "responses",
+    owner: "extension",
+    bodyKind: "json",
+    requestedModelSource: "request"
+  },
+  "images.generate": {
+    id: "images.generate",
+    policyFamily: "images",
+    routeFamily: "images",
+    owner: "extension",
+    bodyKind: "json",
+    requestedModelSource: "configured"
+  },
+  "images.edit": {
+    id: "images.edit",
+    policyFamily: "images",
+    routeFamily: "images",
+    owner: "extension",
+    bodyKind: "multipart",
+    requestedModelSource: "configured"
+  }
+};
+var MATCH_ORDER = [
+  { id: "responses.compact", suffix: ["responses", "compact"] },
+  { id: "images.generate", suffix: ["images", "generations"] },
+  { id: "images.edit", suffix: ["images", "edits"] },
+  { id: "chat.completions.create", suffix: ["chat", "completions"] },
+  { id: "responses.create", suffix: ["responses"] }
+];
+function getOpenAIOperation(id) {
+  return OPERATIONS[id];
+}
+function pathSegments(url) {
+  const queryIndex = url.indexOf("?");
+  const path = queryIndex >= 0 ? url.slice(0, queryIndex) : url;
+  return path.split("/").filter(Boolean);
+}
+function hasExactSuffix(segments, suffix) {
+  if (segments.length < suffix.length) return false;
+  const offset = segments.length - suffix.length;
+  return suffix.every((segment, index) => segments[offset + index] === segment);
+}
+function classifyOpenAIOperation(method, url) {
+  if (method !== "POST" || !url) return null;
+  const segments = pathSegments(url);
+  for (const candidate of MATCH_ORDER) {
+    if (hasExactSuffix(segments, candidate.suffix)) return OPERATIONS[candidate.id];
+  }
+  return null;
+}
+
+// src/openai-operation/openAIOperationRegistry.ts
+var OpenAIOperationRegistrationError = (_class = class extends Error {
+  constructor(code, message) {
+    super(message);_class.prototype.__init.call(this);;
+    this.code = code;
+  }
+  
+  __init() {this.name = "OpenAIOperationRegistrationError"}
+}, _class);
+var OpenAIOperationError = (_class2 = class extends Error {
+  __init2() {this.name = "OpenAIOperationError"}
+  
+  
+  
+  
+  constructor(init) {
+    super(init.message);_class2.prototype.__init2.call(this);;
+    this.status = init.status;
+    this.code = init.code;
+    this.retryable = _nullishCoalesce(init.retryable, () => ( false));
+    this.headers = _nullishCoalesce(init.headers, () => ( {}));
+  }
+}, _class2);
+var SAFE_LOCAL_ERROR_HEADERS = /* @__PURE__ */ new Set(["retry-after", "x-request-id"]);
+function safeErrorHeaders(headers) {
+  const safe = {};
+  for (const [name, value] of Object.entries(headers)) {
+    if (SAFE_LOCAL_ERROR_HEADERS.has(name.toLowerCase())) safe[name] = value;
+  }
+  return safe;
+}
+function writeOpenAIOperationError(res, error) {
+  if (res.headersSent || res.writableEnded) return false;
+  res.writeHead(error.status, {
+    "Content-Type": "application/json",
+    ...safeErrorHeaders(error.headers)
+  });
+  res.end(JSON.stringify({
+    error: {
+      type: "openai_operation_error",
+      code: error.code,
+      message: error.message,
+      retryable: error.retryable
+    }
+  }));
+  return true;
+}
+function unsupportedOpenAIOperation(operation) {
+  return new OpenAIOperationError({
+    status: 501,
+    code: "unsupported_capability",
+    message: `Operation '${operation.id}' is not available`
+  });
+}
+var OpenAIOperationRegistry = (_class3 = class {constructor() { _class3.prototype.__init3.call(this); }
+  __init3() {this.handlers = /* @__PURE__ */ new Map()}
+  register(operationId, handler) {
+    const operation = getOpenAIOperation(operationId);
+    if (operation.owner !== "extension") {
+      throw new OpenAIOperationRegistrationError(
+        "builtin_operation",
+        `Operation '${operationId}' is owned by a built-in ingress`
+      );
+    }
+    if (this.handlers.has(operationId)) {
+      throw new OpenAIOperationRegistrationError(
+        "duplicate_operation_handler",
+        `Operation '${operationId}' already has a handler`
+      );
+    }
+    this.handlers.set(operationId, handler);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      if (this.handlers.get(operationId) === handler) this.handlers.delete(operationId);
+    };
+  }
+  has(operationId) {
+    return this.handlers.has(operationId);
+  }
+  async dispatch(context) {
+    const handler = this.handlers.get(context.operation.id);
+    if (!handler) return false;
+    const controller = new AbortController();
+    const abort = () => {
+      if (!controller.signal.aborted) controller.abort();
+    };
+    const onRequestClose = () => {
+      if (context.request.aborted || !context.request.complete) abort();
+    };
+    const onResponseClose = () => {
+      if (!context.response.writableEnded) abort();
+    };
+    context.request.once("aborted", abort);
+    context.request.once("close", onRequestClose);
+    context.response.once("close", onResponseClose);
+    if (context.request.aborted || context.response.destroyed) abort();
+    try {
+      await handler({ ...context, signal: controller.signal });
+      return true;
+    } catch (error) {
+      const publicError = error instanceof OpenAIOperationError ? error : new OpenAIOperationError({
+        status: 500,
+        code: "operation_handler_failed",
+        message: `Operation '${context.operation.id}' handler failed`
+      });
+      if (!writeOpenAIOperationError(context.response, publicError)) {
+        throw new Error(publicError.message);
+      }
+      return true;
+    } finally {
+      context.request.removeListener("aborted", abort);
+      context.request.removeListener("close", onRequestClose);
+      context.response.removeListener("close", onResponseClose);
+    }
+  }
+}, _class3);
+
+
+
+
+
+
+
+
+
+exports.getOpenAIOperation = getOpenAIOperation; exports.classifyOpenAIOperation = classifyOpenAIOperation; exports.OpenAIOperationRegistrationError = OpenAIOperationRegistrationError; exports.OpenAIOperationError = OpenAIOperationError; exports.writeOpenAIOperationError = writeOpenAIOperationError; exports.unsupportedOpenAIOperation = unsupportedOpenAIOperation; exports.OpenAIOperationRegistry = OpenAIOperationRegistry;