@lakphy/local-router 0.5.0 → 0.5.2

package/dist/entry.js

@@ -53899,7 +53899,15 @@ function subscribeLogEvents(subscriber) {
 }
 
 // src/logger.ts
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import {
+  appendFileSync,
+  closeSync as closeSync2,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  openSync as openSync2,
+  statSync as statSync2,
+  writeSync
+} from "fs";
 import { join as join8 } from "path";
 class Logger {
   baseDir;
@@ -53963,22 +53971,73 @@ class Logger {
       console.error("[logger] \u4E8B\u4EF6\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
     }
   }
-  writeStreamFile(requestId, dateStr, content) {
-    if (!this._enabled || !this._streamsEnabled)
-      return null;
+  openStreamCapture(requestId, dateStr) {
+    if (!this._enabled || !this._streamsEnabled) {
+      return makeNoopStreamCaptureHandle();
+    }
+    const maxStreamBytes = this.maxStreamBytes;
+    const truncationMarker = Buffer.from(`
+[TRUNCATED]`);
+    let filePath;
+    let fd;
     try {
       const dir = this.ensureStreamDateDir(dateStr);
-      const filePath = join8(dir, `${requestId}.sse.raw`);
-      const toWrite = content.length > this.maxStreamBytes ? `${content.slice(0, this.maxStreamBytes)}
-[TRUNCATED]` : content;
-      writeFileSync3(filePath, toWrite);
-      return filePath;
+      filePath = join8(dir, `${requestId}.sse.raw`);
+      fd = openSync2(filePath, "a");
     } catch (err) {
-      console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
-      return null;
+      console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u6253\u5F00\u5931\u8D25:", err);
+      return makeNoopStreamCaptureHandle();
     }
+    let bytes = 0;
+    let truncated = false;
+    let finalized = false;
+    return {
+      filePath,
+      write(chunk) {
+        if (finalized || truncated || fd == null)
+          return;
+        try {
+          if (bytes + chunk.byteLength > maxStreamBytes) {
+            const remaining = Math.max(0, maxStreamBytes - bytes);
+            if (remaining > 0) {
+              writeSync(fd, chunk.subarray(0, remaining));
+              bytes += remaining;
+            }
+            writeSync(fd, truncationMarker);
+            truncated = true;
+            return;
+          }
+          writeSync(fd, chunk);
+          bytes += chunk.byteLength;
+        } catch (err) {
+          console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5199\u5165\u5931\u8D25:", err);
+          truncated = true;
+        }
+      },
+      finalize() {
+        if (finalized)
+          return { bytesWritten: bytes, truncated, filePath };
+        finalized = true;
+        if (fd != null) {
+          try {
+            closeSync2(fd);
+          } catch {}
+          fd = null;
+        }
+        return { bytesWritten: bytes, truncated, filePath };
+      }
+    };
   }
 }
+function makeNoopStreamCaptureHandle() {
+  return {
+    filePath: null,
+    write() {},
+    finalize() {
+      return { bytesWritten: 0, truncated: false, filePath: null };
+    }
+  };
+}
 var instance = null;
 function initLogger(baseDir, config2) {
   instance = new Logger(baseDir, config2);
@@ -55370,11 +55429,6 @@ class PluginManager {
   }
 }
 
-// src/proxy.ts
-import { appendFile, readFile, unlink } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import { join as join10 } from "path";
-
 // src/plugin-engine.ts
 async function executeRequestPlugins(plugins, ctx, url2, headers, body) {
   let currentUrl = url2;
@@ -55564,28 +55618,6 @@ function buildLogEvent(logMeta, targetUrl, proxyUrl, tsEnd, overrides) {
     ...overrides
   };
 }
-function createTempStreamCapturePath(requestId) {
-  return join10(tmpdir2(), `local-router-stream-${requestId}-${Date.now()}.sse.raw`);
-}
-async function appendTempStreamCapture(filePath, chunk) {
-  await appendFile(filePath, chunk);
-}
-async function flushTempCaptureToLogger(tempPath, requestId, dateStr, logger) {
-  if (!logger)
-    return null;
-  try {
-    const text2 = await readFile(tempPath, "utf-8").catch((err) => {
-      if (err.code === "ENOENT")
-        return "";
-      throw err;
-    });
-    return logger.writeStreamFile(requestId, dateStr, text2);
-  } finally {
-    await unlink(tempPath).catch(() => {
-      return;
-    });
-  }
-}
 async function proxyRequest(c2, options) {
   const { logMeta, plugins, pluginConfigs } = options;
   const logger = getLogger();
@@ -55593,19 +55625,20 @@ async function proxyRequest(c2, options) {
   const hasPlugins = plugins && plugins.length > 0;
   let targetUrl = options.targetUrl;
   let headers = buildUpstreamHeaders(c2.req.raw.headers, options.apiKey, options.authType);
-  let bodyStr = options.body;
+  let currentBody = options.body;
+  const pluginCtx = Object.freeze({
+    requestId: logMeta.requestId,
+    provider: logMeta.provider,
+    modelIn: logMeta.modelIn,
+    modelOut: logMeta.modelOut,
+    routeType: logMeta.routeType,
+    isStream: logMeta.isStream
+  });
+  const wantsBodyLog = shouldLog && logger?.bodyPolicy !== "off";
+  const requestBodySnapshot = wantsBodyLog ? JSON.parse(JSON.stringify(options.body)) : undefined;
   const pluginLogOverrides = {};
   if (hasPlugins) {
-    const bodyObj = JSON.parse(bodyStr);
-    const ctx = {
-      requestId: logMeta.requestId,
-      provider: logMeta.provider,
-      modelIn: logMeta.modelIn,
-      modelOut: logMeta.modelOut,
-      routeType: logMeta.routeType,
-      isStream: logMeta.isStream
-    };
-    const result = await executeRequestPlugins(plugins, ctx, targetUrl, headers, bodyObj);
+    const result = await executeRequestPlugins(plugins, pluginCtx, targetUrl, headers, currentBody);
     if (pluginConfigs) {
       pluginLogOverrides.plugins_request = pluginConfigs;
     }
@@ -55614,20 +55647,20 @@ async function proxyRequest(c2, options) {
       pluginLogOverrides.request_url_after_plugins = targetUrl;
     }
     headers = result.headers;
-    const newBodyStr = JSON.stringify(result.body);
-    if (newBodyStr !== bodyStr) {
-      bodyStr = newBodyStr;
+    if (result.body !== currentBody) {
+      currentBody = result.body;
       pluginLogOverrides.request_body_after_plugins = result.body;
     }
   }
-  const requestBody = shouldLog && logger?.bodyPolicy !== "off" ? JSON.parse(options.body) : undefined;
+  const wireBody = JSON.stringify(currentBody);
+  const requestBody = requestBodySnapshot;
   const proxy = options.proxy?.trim() ? options.proxy.trim() : undefined;
   let upstreamRes;
   try {
     upstreamRes = await fetch(targetUrl, {
       method: c2.req.method,
       headers,
-      body: bodyStr,
+      body: wireBody,
       ...proxy ? { proxy } : {},
       decompress: true
     });
@@ -55657,15 +55690,7 @@ async function proxyRequest(c2, options) {
     let sseHeaders = responseHeaders;
     let sseTransform = null;
     if (hasPlugins) {
-      const ctx = {
-        requestId: logMeta.requestId,
-        provider: logMeta.provider,
-        modelIn: logMeta.modelIn,
-        modelOut: logMeta.modelOut,
-        routeType: logMeta.routeType,
-        isStream: logMeta.isStream
-      };
-      const sseResult = await createSSEPluginTransform(plugins, ctx, upstreamRes.status, responseHeaders);
+      const sseResult = await createSSEPluginTransform(plugins, pluginCtx, upstreamRes.status, responseHeaders);
       sseStatus = sseResult.status;
       sseHeaders = sseResult.headers;
       sseTransform = sseResult.transform;
@@ -55674,47 +55699,71 @@ async function proxyRequest(c2, options) {
       }
     }
     if (!shouldLog) {
-      const outputBody2 = sseTransform ? upstreamRes.body.pipeThrough(sseTransform) : upstreamRes.body;
-      return new Response(outputBody2, {
+      const outputBody = sseTransform ? upstreamRes.body.pipeThrough(sseTransform) : upstreamRes.body;
+      return new Response(outputBody, {
         status: sseStatus,
         headers: sseHeaders
       });
     }
-    const [clientStream, logStream] = upstreamRes.body.tee();
-    (async () => {
-      const tempPath = createTempStreamCapturePath(logMeta.requestId);
-      let streamBytes = 0;
-      let streamFile = null;
-      try {
-        const reader = logStream.getReader();
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done)
-            break;
-          streamBytes += value.byteLength;
-          await appendTempStreamCapture(tempPath, value);
+    const capture = logger?.openStreamCapture(logMeta.requestId, dateStr) ?? null;
+    let upstreamBytes = 0;
+    let writeEventCalled = false;
+    const finalizeAndWriteEvent = () => {
+      if (writeEventCalled)
+        return;
+      writeEventCalled = true;
+      const captureResult = capture?.finalize() ?? {
+        bytesWritten: 0,
+        truncated: false,
+        filePath: null
+      };
+      logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
+        upstream_status: sseStatus,
+        content_type_res: contentTypeRes,
+        response_headers: sseHeaders,
+        stream_bytes: upstreamBytes,
+        provider_request_id: providerRequestId,
+        ...captureResult.filePath != null && { stream_file: captureResult.filePath },
+        ...captureResult.bytesWritten > 0 && {
+          stream_file_bytes: captureResult.bytesWritten
+        },
+        ...captureResult.truncated && { stream_file_truncated: true },
+        ...requestBody !== undefined && { request_body: requestBody },
+        ...pluginLogOverrides
+      }));
+    };
+    const upstreamReader = upstreamRes.body.getReader();
+    const tappedStream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const { done, value } = await upstreamReader.read();
+          if (done) {
+            controller.close();
+            finalizeAndWriteEvent();
+            return;
+          }
+          upstreamBytes += value.byteLength;
+          capture?.write(value);
+          controller.enqueue(value);
+        } catch (err) {
+          finalizeAndWriteEvent();
+          controller.error(err);
+        }
+      },
+      cancel(reason) {
+        try {
+          upstreamReader.cancel(reason).catch(() => {
+            return;
+          });
+        } finally {
+          finalizeAndWriteEvent();
         }
-        streamFile = await flushTempCaptureToLogger(tempPath, logMeta.requestId, dateStr, logger);
-      } catch (err) {
-        await unlink(tempPath).catch(() => {
-          return;
-        });
-        console.error("[logger] \u6D41\u5F0F\u65E5\u5FD7\u5904\u7406\u5931\u8D25:", err);
-      } finally {
-        logger?.writeEvent(buildLogEvent(logMeta, targetUrl, proxy, Date.now(), {
-          upstream_status: sseStatus,
-          content_type_res: contentTypeRes,
-          response_headers: sseHeaders,
-          stream_bytes: streamBytes,
-          provider_request_id: providerRequestId,
-          ...streamFile != null && { stream_file: streamFile },
-          ...requestBody !== undefined && { request_body: requestBody },
-          ...pluginLogOverrides
-        }));
       }
-    })();
-    const outputBody = sseTransform ? clientStream.pipeThrough(sseTransform) : clientStream;
-    return new Response(outputBody, {
+    });
+    let stream = tappedStream;
+    if (sseTransform)
+      stream = stream.pipeThrough(sseTransform);
+    return new Response(stream, {
       status: sseStatus,
       headers: sseHeaders
     });
@@ -55723,15 +55772,7 @@ async function proxyRequest(c2, options) {
   let responseStatus = upstreamRes.status;
   let finalResponseHeaders = responseHeaders;
   if (hasPlugins) {
-    const ctx = {
-      requestId: logMeta.requestId,
-      provider: logMeta.provider,
-      modelIn: logMeta.modelIn,
-      modelOut: logMeta.modelOut,
-      routeType: logMeta.routeType,
-      isStream: logMeta.isStream
-    };
-    const result = await executeJsonResponsePlugins(plugins, ctx, upstreamRes.status, responseHeaders, responseText);
+    const result = await executeJsonResponsePlugins(plugins, pluginCtx, upstreamRes.status, responseHeaders, responseText);
     if (pluginConfigs) {
       pluginLogOverrides.plugins_response = pluginConfigs;
     }
@@ -55808,8 +55849,10 @@ function createModelRoutingHandler(options) {
       return c2.json({ error: `provider "${target.provider}" \u672A\u5728\u914D\u7F6E\u4E2D\u5B9A\u4E49` }, 500);
     }
     payload.model = target.model;
-    const body = JSON.stringify(payload);
     const targetUrl = buildTargetUrl(provider.base);
+    const contentLengthHeader = c2.req.header("content-length");
+    const parsedContentLength = contentLengthHeader ? Number(contentLengthHeader) : NaN;
+    const requestBytes = Number.isInteger(parsedContentLength) && parsedContentLength >= 0 ? parsedContentLength : Buffer.byteLength(JSON.stringify(payload), "utf-8");
     const logMeta = {
       requestId: crypto.randomUUID(),
       tsStart: Date.now(),
@@ -55823,7 +55866,7 @@ function createModelRoutingHandler(options) {
       path: c2.req.path,
       contentTypeReq: c2.req.header("content-type") ?? null,
       userAgent: c2.req.header("user-agent") ?? null,
-      requestBytes: Buffer.byteLength(body, "utf-8"),
+      requestBytes,
       requestHeaders: collectHeaders(c2.req.raw.headers)
     };
     const plugins = pluginManager?.getPlugins(target.provider) ?? [];
@@ -55833,7 +55876,7 @@ function createModelRoutingHandler(options) {
       apiKey: provider.apiKey,
       proxy: provider.proxy,
       authType,
-      body,
+      body: payload,
       logMeta,
       plugins: plugins.length > 0 ? plugins : undefined,
       pluginConfigs: pluginConfigs.length > 0 ? pluginConfigs.map((lp) => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lakphy/local-router",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "packageManager": "bun@1.2.0",
   "workspaces": [
     "web"