@omnicross/core 0.1.6 → 0.1.7

package/dist/{chunk-AT7B7SOZ.js → chunk-5NJLQ6T6.js}

@@ -81,6 +81,20 @@ function flattenToolResultContent(content) {
 }
 
 // src/api-converter/anthropic-to-openai.ts
+function anthropicUsageToChatUsage(usage) {
+  const input = usage.input_tokens || 0;
+  const output = usage.output_tokens || 0;
+  const cacheRead = usage.cache_read_input_tokens || 0;
+  const cacheCreation = usage.cache_creation_input_tokens || 0;
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) out.prompt_tokens_details = { cached_tokens: cacheRead };
+  return out;
+}
 function convertAnthropicToOpenAI(response) {
   const content = [];
   const toolCalls = [];
@@ -118,11 +132,7 @@ function convertAnthropicToOpenAI(response) {
         finish_reason: finishReason
       }
     ],
-    usage: {
-      prompt_tokens: response.usage.input_tokens,
-      completion_tokens: response.usage.output_tokens,
-      total_tokens: response.usage.input_tokens + response.usage.output_tokens
-    }
+    usage: anthropicUsageToChatUsage(response.usage)
   };
   if (reasoningContent) {
     result.reasoning_content = reasoningContent;
@@ -352,11 +362,12 @@ async function* convertAnthropicStreamToOpenAI(anthropicStream) {
                 delta: {},
                 finish_reason: finishReason
               }],
-              usage: event.usage ? {
-                prompt_tokens: event.usage.input_tokens || 0,
-                completion_tokens: event.usage.output_tokens || 0,
-                total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0)
-              } : void 0
+              usage: event.usage ? anthropicUsageToChatUsage({
+                input_tokens: event.usage.input_tokens || 0,
+                output_tokens: event.usage.output_tokens || 0,
+                cache_read_input_tokens: event.usage.cache_read_input_tokens,
+                cache_creation_input_tokens: event.usage.cache_creation_input_tokens
+              }) : void 0
             })}
 
 `;

package/dist/chunk-5RSZYQJH.cjs

@@ -0,0 +1,62 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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; }// src/transformer/transformers/utils/usage-mapping.ts
+function num(obj, key) {
+  const v = _optionalChain([obj, 'optionalAccess', _ => _[key]]);
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function detailCachedTokens(obj, detailKey) {
+  const detail = _optionalChain([obj, 'optionalAccess', _2 => _2[detailKey]]);
+  return num(detail, "cached_tokens");
+}
+function anthropicUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const cacheRead = num(usage, "cache_read_input_tokens");
+  const cacheCreation = num(usage, "cache_creation_input_tokens");
+  const promptTokens = input + cacheRead + cacheCreation;
+  const out = {
+    prompt_tokens: promptTokens,
+    completion_tokens: output,
+    total_tokens: promptTokens + output
+  };
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function chatUsageToResponsesUsage(usage) {
+  if (!usage) return void 0;
+  const prompt = num(usage, "prompt_tokens");
+  const completion = num(usage, "completion_tokens");
+  const out = {
+    input_tokens: prompt,
+    output_tokens: completion,
+    total_tokens: num(usage, "total_tokens") || prompt + completion
+  };
+  const cacheRead = detailCachedTokens(usage, "prompt_tokens_details");
+  if (cacheRead > 0) {
+    out.input_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+function responsesUsageToChatUsage(usage) {
+  if (!usage) return void 0;
+  const input = num(usage, "input_tokens");
+  const output = num(usage, "output_tokens");
+  const out = {
+    prompt_tokens: input,
+    completion_tokens: output,
+    total_tokens: num(usage, "total_tokens") || input + output
+  };
+  const cacheRead = detailCachedTokens(usage, "input_tokens_details");
+  if (cacheRead > 0) {
+    out.prompt_tokens_details = { cached_tokens: cacheRead };
+  }
+  return out;
+}
+
+
+
+
+
+exports.anthropicUsageToChatUsage = anthropicUsageToChatUsage; exports.chatUsageToResponsesUsage = chatUsageToResponsesUsage; exports.responsesUsageToChatUsage = responsesUsageToChatUsage;

package/dist/{chunk-IFXJ2BG7.js → chunk-7C7DET6S.js}

@@ -11,6 +11,29 @@ import {
 
 // src/outbound-api/auditCapture.ts
 import { randomUUID } from "crypto";
+function completeUtf8PrefixLength(buf) {
+  if (buf.length === 0) return 0;
+  let leadIndex = buf.length - 1;
+  while (leadIndex >= 0 && (buf[leadIndex] & 192) === 128) leadIndex -= 1;
+  if (leadIndex < 0) return 0;
+  const lead = buf[leadIndex];
+  let expectedLength = 1;
+  if ((lead & 224) === 192) expectedLength = 2;
+  else if ((lead & 240) === 224) expectedLength = 3;
+  else if ((lead & 248) === 240) expectedLength = 4;
+  return buf.length - leadIndex < expectedLength ? leadIndex : buf.length;
+}
+function truncateToBytes(text, maxBytes) {
+  if (maxBytes < 0) return text;
+  const buf = Buffer.from(text, "utf8");
+  if (buf.length <= maxBytes) return text;
+  const head = buf.subarray(0, maxBytes);
+  return head.subarray(0, completeUtf8PrefixLength(head)).toString("utf8");
+}
+function decodeCapturedBody(body, truncated) {
+  if (!truncated) return body.toString("utf8");
+  return body.subarray(0, completeUtf8PrefixLength(body)).toString("utf8");
+}
 function resolveClientIp(req, trustForwardedFor) {
   if (trustForwardedFor) {
     const xff = req.headers["x-forwarded-for"];
@@ -25,18 +48,39 @@ function resolveClientIp(req, trustForwardedFor) {
 function beginAuditCapture(req, res, now) {
   const config = getAuditCaptureConfig();
   if (!config) return null;
-  let rawRequestBody;
+  let requestBody;
   const responseChunks = [];
+  let responseBytes = 0;
+  let responseTruncated = false;
   let finished = false;
   const ctx = {
     setRequestBody(raw) {
-      if (config.captureBodies) rawRequestBody = raw;
+      if (config.captureBodies) {
+        requestBody = truncateToBytes(redactAuditText(raw), config.maxBodyBytes);
+      }
     }
   };
   if (config.captureBodies) {
     installResponseCapture(res, {
       push(chunk) {
+        if (config.maxBodyBytes < 0) {
+          responseChunks.push(chunk);
+          responseBytes += chunk.length;
+          return;
+        }
+        const remaining = config.maxBodyBytes - responseBytes;
+        if (remaining <= 0) {
+          responseTruncated = true;
+          return;
+        }
+        if (chunk.length > remaining) {
+          responseChunks.push(chunk.subarray(0, remaining));
+          responseBytes += remaining;
+          responseTruncated = true;
+          return;
+        }
         responseChunks.push(chunk);
+        responseBytes += chunk.length;
       }
     });
   }
@@ -69,12 +113,13 @@ function beginAuditCapture(req, res, now) {
       }
       if (ctx.error) record.error = redactAuditText(ctx.error);
       if (config.captureBodies) {
-        if (rawRequestBody != null && rawRequestBody.length > 0) {
-          record.requestBody = redactAuditText(rawRequestBody);
+        if (requestBody != null && requestBody.length > 0) {
+          record.requestBody = requestBody;
         }
         if (responseChunks.length > 0) {
-          const body = Buffer.concat(responseChunks).toString("utf8");
-          record.responseBody = redactAuditText(body);
+          const captured = Buffer.concat(responseChunks, responseBytes);
+          const body = decodeCapturedBody(captured, responseTruncated);
+          record.responseBody = truncateToBytes(redactAuditText(body), config.maxBodyBytes);
         }
       }
       recordAudit(record);