kimi-proxy 0.1.3 → 0.1.5

package/README.md

@@ -137,6 +137,15 @@ The API runs on `http://127.0.0.1:8000` and serves the dashboard (built assets)
 
 ## Configuration
 
+### Dashboard & LiveStore
+
+Control LiveStore sync behavior via environment variables:
+
+| Variable                | Default | Description                                                                                     |
+| ----------------------- | ------- | ----------------------------------------------------------------------------------------------- |
+| `LIVESTORE_BATCH`       | 50      | Batch size for dashboard sync (range: 1-500)                                                    |
+| `LIVESTORE_MAX_RECORDS` | 500     | Memory sliding window - max records to keep in LiveStore. Set to 0 to disable (not recommended) |
+
 ### Providers
 
 Set environment variables in `.env`:
@@ -169,6 +178,15 @@ models:
 
 The web dashboard shows request/response logs and metrics. Access it at the root path when running the proxy. LiveStore metadata sync pulls from `/api/livestore/pull` in batches (size controlled by `LIVESTORE_BATCH`) and lazily fetches blobs on expansion. Build the dashboard with `bun run build:all` to serve static assets from the backend.
 
+### Performance Features
+
+- **Reverse-chronological loading**: Data loads from newest to oldest, providing immediate access to recent logs
+- **Memory-efficient virtualization**: Uses TanStack Virtual to render only visible rows
+- **Configurable sliding window**: Limit browser memory usage by setting `LIVESTORE_MAX_RECORDS` (see `.env.example`)
+- **Automatic garbage collection**: Old records beyond the window limit are automatically purged
+
+The dashboard uses reactive queries with TanStack Table and TanStack Virtual for fast, efficient rendering of large datasets.
+
 ## Development
 
 ```bash

package/dist/config.d.ts

@@ -17,6 +17,7 @@ export interface AppConfig {
     };
     livestore: {
         batchSize: number;
+        maxRecords?: number;
     };
     providers: {
         openai?: OpenAIConfig;

package/dist/core/clientAdapters.d.ts

@@ -9,7 +9,7 @@ export declare class OpenAIChatClientAdapter implements ClientAdapter {
 export declare class AnthropicMessagesClientAdapter implements ClientAdapter {
     clientFormat: ClientFormat;
     toUlx(body: ClientRequest, headers: Record<string, string>): Request;
-    fromUlx(ulxResponse: Response): JsonValue;
+    fromUlx(ulxResponse: Response, _ulxRequest: Request): JsonValue;
 }
 export declare class OpenAIResponsesClientAdapter implements ClientAdapter {
     clientFormat: ClientFormat;

package/dist/index.js

@@ -91,6 +91,7 @@ function loadConfig() {
   const streamDelay = Number(process.env.STREAM_DELAY ?? "10");
   const streamChunkSize = Number(process.env.STREAM_CHUNK_SIZE ?? "5");
   const livestoreBatch = Number(process.env.LIVESTORE_BATCH ?? "50");
+  const livestoreMaxRecords = process.env.LIVESTORE_MAX_RECORDS ? Number(process.env.LIVESTORE_MAX_RECORDS) : 500;
   const openai = resolveOpenAI();
   const anthropic = resolveAnthropic();
   const openrouter = resolveOpenRouter();
@@ -116,7 +117,10 @@ function loadConfig() {
     server: { host, port },
     logging: { dbPath, blobRoot },
     streaming: { delay: streamDelay, chunkSize: streamChunkSize },
-    livestore: { batchSize: Math.max(1, Math.min(500, livestoreBatch)) },
+    livestore: {
+      batchSize: Math.max(1, Math.min(500, livestoreBatch)),
+      maxRecords: livestoreMaxRecords
+    },
     providers: { openai, anthropic, openrouter, vertex },
     models: modelRegistry
   };
@@ -768,12 +772,12 @@ class HybridLogStore {
     const clauses = [];
     const params = { limit };
     if (checkpoint.timestamp) {
-      clauses.push(`(timestamp > @ts OR (timestamp = @ts AND id > @id))`);
+      clauses.push(`(timestamp < @ts OR (timestamp = @ts AND id < @id))`);
       params.ts = checkpoint.timestamp;
-      params.id = checkpoint.id ?? 0;
+      params.id = checkpoint.id ?? Number.MAX_SAFE_INTEGER;
     }
     const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
-    const rows = this.db.prepare(`SELECT * FROM logs ${where} ORDER BY datetime(timestamp), id LIMIT @limit`).all(params);
+    const rows = this.db.prepare(`SELECT * FROM logs ${where} ORDER BY datetime(timestamp) DESC, id DESC LIMIT @limit`).all(params);
     return { items: rows, total: rows.length, page: 1, pageSize: rows.length };
   }
   resolveBlobPath(record, kind) {
@@ -1554,33 +1558,36 @@ class OpenAIChatClientAdapter {
     };
   }
   fromUlx(ulxResponse, _ulxRequest) {
-    const contentBlocks = ulxResponse.output.find((entry) => entry.type === "message");
-    let content = null;
-    let reasoning_content = undefined;
-    if (contentBlocks?.type === "message") {
-      const textParts = [];
-      const reasoningParts = [];
-      for (const entry of contentBlocks.content) {
-        if (entry.type === "text") {
-          textParts.push(entry.text ?? "");
-        } else if (entry.type === "reasoning") {
-          reasoningParts.push(entry.text ?? "");
+    const textParts = [];
+    const reasoningParts = [];
+    let toolCalls = undefined;
+    for (const block of ulxResponse.output) {
+      if (block.type === "message") {
+        for (const entry of block.content) {
+          if (entry.type === "reasoning") {
+            reasoningParts.push(entry.text ?? "");
+          }
+        }
+        const meaningfulContent = block.content.filter((c) => c.type !== "reasoning");
+        if (meaningfulContent.length > 0) {
+          const mixed = contentToText(meaningfulContent);
+          textParts.push(typeof mixed === "string" ? mixed : JSON.stringify(mixed));
+        }
+        if (block.tool_calls) {
+          toolCalls = [...toolCalls ?? [], ...block.tool_calls];
+        }
+      } else if (block.type === "reasoning") {
+        for (const entry of block.content) {
+          if (entry.type === "reasoning") {
+            reasoningParts.push(entry.text ?? "");
+          }
         }
-      }
-      if (textParts.length > 0) {
-        content = textParts.join("");
-      } else if (contentBlocks.content.some((c) => c.type === "image_url" || c.type === "json")) {
-        const mixed = contentToText(contentBlocks.content.filter((c) => c.type !== "reasoning"));
-        content = typeof mixed === "string" ? mixed : JSON.stringify(mixed);
-      } else {
-        content = null;
-      }
-      if (reasoningParts.length > 0) {
-        reasoning_content = reasoningParts.join(`
-
-`);
       }
     }
+    const content = textParts.join("") || null;
+    const reasoning_content = reasoningParts.join(`
+
+`) || undefined;
     return {
       id: ulxResponse.id,
       object: "chat.completion",
@@ -1591,9 +1598,9 @@ class OpenAIChatClientAdapter {
           index: 0,
           message: {
             role: "assistant",
-            content,
             ...reasoning_content ? { reasoning_content } : {},
-            tool_calls: contentBlocks?.type === "message" && contentBlocks.tool_calls ? contentBlocks.tool_calls.map((tc) => ({
+            content,
+            tool_calls: toolCalls ? toolCalls.map((tc) => ({
               id: tc.id,
               type: "function",
               function: {
@@ -1683,7 +1690,11 @@ class AnthropicMessagesClientAdapter {
     function anthropicBlockToUlxContent(block) {
       const declaredType = typeof block.type === "string" ? block.type : "";
       if (declaredType === "thinking" || declaredType === "redacted_thinking" || typeof block.thinking === "string") {
-        return;
+        return {
+          type: "reasoning",
+          text: block.thinking ?? block.text ?? "",
+          data: block.signature ? { signature: block.signature } : declaredType === "redacted_thinking" ? { redacted: true } : undefined
+        };
       }
       if (typeof block.text === "string") {
         return { type: "text", text: block.text };
@@ -1799,37 +1810,57 @@ class AnthropicMessagesClientAdapter {
       metadata: { clientFormat: this.clientFormat, headers }
     };
   }
-  fromUlx(ulxResponse) {
-    const contentBlocks = ulxResponse.output.find((entry) => entry.type === "message");
-    const messageContent = contentBlocks?.type === "message" ? contentToText(contentBlocks.content) : "";
-    const content = [];
-    if (typeof messageContent === "string") {
-      if (messageContent)
-        content.push({ type: "text", text: messageContent });
-    } else if (Array.isArray(messageContent)) {
-      for (const item of messageContent) {
-        if (item && typeof item === "object") {
-          const block = item;
-          if (block.type === "thinking") {
-            content.push(block);
-          } else if (block.type === "text") {
-            content.push(block);
+  fromUlx(ulxResponse, _ulxRequest) {
+    const thinkingBlocks = [];
+    const textBlocks = [];
+    const toolUseBlocks = [];
+    for (const block of ulxResponse.output) {
+      if (block.type === "reasoning") {
+        for (const entry of block.content) {
+          if (entry.type === "reasoning") {
+            thinkingBlocks.push({
+              type: "thinking",
+              thinking: entry.text ?? "",
+              signature: entry.data?.signature
+            });
+          }
+        }
+      } else if (block.type === "message") {
+        const messageContent = contentToText(block.content);
+        if (typeof messageContent === "string") {
+          if (messageContent)
+            textBlocks.push({ type: "text", text: messageContent });
+        } else if (Array.isArray(messageContent)) {
+          for (const item of messageContent) {
+            if (item && typeof item === "object") {
+              const b = item;
+              if (b.type === "thinking") {
+                thinkingBlocks.push(b);
+              } else if (b.type === "text") {
+                textBlocks.push(b);
+              }
+            }
+          }
+        } else if (typeof messageContent === "object" && messageContent !== null && "text" in messageContent) {
+          textBlocks.push(messageContent);
+        }
+        if (block.tool_calls) {
+          for (const tc of block.tool_calls) {
+            toolUseBlocks.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.name,
+              input: JSON.parse(tc.arguments)
+            });
           }
         }
-      }
-    } else if (typeof messageContent === "object" && messageContent !== null && "text" in messageContent) {
-      content.push(messageContent);
-    }
-    if (contentBlocks?.type === "message" && contentBlocks.tool_calls) {
-      for (const tc of contentBlocks.tool_calls) {
-        content.push({
-          type: "tool_use",
-          id: tc.id,
-          name: tc.name,
-          input: JSON.parse(tc.arguments)
-        });
       }
     }
+    const content = [
+      ...thinkingBlocks,
+      ...textBlocks,
+      ...toolUseBlocks
+    ];
     return {
       id: ulxResponse.id,
       type: "message",
@@ -2089,18 +2120,19 @@ class OpenAIResponsesClientAdapter {
   }
   fromUlx(ulxResponse, ulxRequest) {
     const outputBlocks = ulxResponse.output;
-    const output = [];
     const textParts = [];
     const createdAt = Math.floor(Date.now() / 1000);
     let messageIndex = 0;
     let functionCallIndex = 0;
     let reasoningIndex = 0;
+    const collectedReasoning = [];
+    const collectedMessages = [];
+    const collectedFunctionCalls = [];
     for (const block of outputBlocks) {
       if (block.type === "message") {
         const messageId = `msg_${ulxResponse.id}_${messageIndex++}`;
         const status = block.status === "incomplete" ? "incomplete" : "completed";
         const content = [];
-        const reasoningContent = [];
         for (const entry of block.content) {
           if (entry.type === "text") {
             const text = entry.text ?? "";
@@ -2119,22 +2151,16 @@ class OpenAIResponsesClientAdapter {
             }
             content.push({ type: "output_text", text, annotations: [] });
           } else if (entry.type === "reasoning") {
-            reasoningContent.push({
-              type: "reasoning_text",
-              text: entry.text ?? ""
+            collectedReasoning.push({
+              type: "reasoning",
+              id: `rsn_${ulxResponse.id}_${reasoningIndex++}`,
+              status: "completed",
+              content: [{ type: "reasoning_text", text: entry.text ?? "" }],
+              summary: []
             });
           }
         }
-        if (reasoningContent.length > 0) {
-          output.push({
-            type: "reasoning",
-            id: `rsn_${ulxResponse.id}_${reasoningIndex++}`,
-            status: "completed",
-            content: reasoningContent,
-            summary: []
-          });
-        }
-        output.push({
+        collectedMessages.push({
           type: "message",
           id: messageId,
           role: "assistant",
@@ -2143,7 +2169,7 @@ class OpenAIResponsesClientAdapter {
         });
         if (block.tool_calls) {
           for (const call of block.tool_calls) {
-            output.push({
+            collectedFunctionCalls.push({
               type: "function_call",
               id: `fc_${ulxResponse.id}_${functionCallIndex++}`,
               call_id: call.id,
@@ -2154,7 +2180,7 @@ class OpenAIResponsesClientAdapter {
           }
         }
       } else if (block.type === "tool_call") {
-        output.push({
+        collectedFunctionCalls.push({
           type: "function_call",
           id: `fc_${ulxResponse.id}_${functionCallIndex++}`,
           call_id: block.call_id,
@@ -2163,7 +2189,7 @@ class OpenAIResponsesClientAdapter {
           status: block.status === "pending" ? "in_progress" : "completed"
         });
       } else if (block.type === "reasoning") {
-        output.push({
+        collectedReasoning.push({
           type: "reasoning",
           id: `rsn_${ulxResponse.id}_${reasoningIndex++}`,
           status: "completed",
@@ -2178,6 +2204,11 @@ class OpenAIResponsesClientAdapter {
         });
       }
     }
+    const output = [
+      ...collectedReasoning,
+      ...collectedMessages,
+      ...collectedFunctionCalls
+    ];
     const inputTokens = ulxResponse.usage?.input_tokens ?? 0;
     const outputTokens = ulxResponse.usage?.output_tokens ?? 0;
     const totalTokens = ulxResponse.usage?.total_tokens ?? inputTokens + outputTokens;
@@ -2387,7 +2418,9 @@ function createCapturingFetch(originalFetch = globalThis.fetch) {
 // src/core/providers/anthropic.ts
 var AnthropicContentSchema = z6.object({
   type: z6.string(),
-  text: z6.string().optional()
+  text: z6.string().optional(),
+  thinking: z6.string().optional(),
+  signature: z6.string().optional()
 }).passthrough();
 var AnthropicResponseSchema = z6.object({
   id: z6.string(),
@@ -2428,6 +2461,13 @@ function toAnthropicContent(blocks) {
   return blocks.map((entry) => {
     if (entry.type === "text")
       return { type: "text", text: entry.text ?? "" };
+    if (entry.type === "reasoning") {
+      return {
+        type: "thinking",
+        thinking: entry.text ?? "",
+        signature: entry.data?.signature
+      };
+    }
     if (entry.type === "image_url") {
       if (typeof entry.url === "string") {
         const match = entry.url.match(/^data:([^;]+);base64,(.+)$/);
@@ -2468,7 +2508,8 @@ function anthropicResponseToUlx(body, request) {
       type: "reasoning",
       content: reasoning.map((part) => ({
         type: "reasoning",
-        text: part.text ?? ""
+        text: part.thinking ?? part.text ?? "",
+        data: part.signature ? { signature: part.signature } : undefined
       })),
       summary: []
     });
@@ -2626,7 +2667,7 @@ var TOOL_SECTION_END = "<|tool_calls_section_end|>";
 function cleanText(text) {
   if (!text)
     return "";
-  return text.replaceAll("(no content)", "").replace(/\n\s*\n\s*\n+/g, `
+  return text.replaceAll("(no content)", "").replace(/<tool_call>[a-zA-Z0-9_:-]+/g, "").replace(/\n\s*\n\s*\n+/g, `
 
 `).trim();
 }
@@ -2752,6 +2793,18 @@ function fixKimiResponse(response, request) {
       const message = choice.message !== undefined && isJsonObject(choice.message) ? choice.message : choice.message = {};
       const rawToolCalls = message.tool_calls;
       let aggregatedToolCalls = Array.isArray(rawToolCalls) ? [...rawToolCalls] : [];
+      if (typeof message.reasoning === "string" && !message.reasoning_content) {
+        message.reasoning_content = message.reasoning;
+      }
+      if (Array.isArray(message.reasoning_details) && !message.reasoning_content) {
+        const details = message.reasoning_details;
+        const text = details.filter((d) => d.type === "reasoning.text" && typeof d.text === "string").map((d) => d.text).join(`
+
+`);
+        if (text) {
+          message.reasoning_content = text;
+        }
+      }
       if (typeof message.reasoning_content === "string") {
         const original = message.reasoning_content;
         const { cleanedText, extracted } = extractToolCallSections(original);
@@ -2953,32 +3006,31 @@ function toOpenAITool(tool) {
 }
 function toOpenAIMessages(messages) {
   return messages.map((msg) => {
+    const reasoningBlocks = msg.content.filter((c) => c.type === "reasoning");
+    const nonReasoningBlocks = msg.content.filter((c) => c.type !== "reasoning");
+    const res = {
+      role: msg.role === "assistant" ? "assistant" : msg.role,
+      content: toOpenAIContent(nonReasoningBlocks)
+    };
+    if (reasoningBlocks.length > 0) {
+      res.reasoning_content = reasoningBlocks.map((b) => b.text).join(`
+
+`);
+    }
     if (msg.role === "tool") {
-      return {
-        role: "tool",
-        tool_call_id: msg.tool_call_id,
-        content: toOpenAIContent(msg.content)
-      };
+      res.tool_call_id = msg.tool_call_id;
     }
     if (msg.tool_calls) {
-      return {
-        role: msg.role,
-        content: toOpenAIContent(msg.content),
-        tool_calls: msg.tool_calls.map((call) => ({
-          id: call.id,
-          type: "function",
-          function: {
-            name: call.name,
-            arguments: call.arguments
-          }
-        }))
-      };
+      res.tool_calls = msg.tool_calls.map((call) => ({
+        id: call.id,
+        type: "function",
+        function: {
+          name: call.name,
+          arguments: call.arguments
+        }
+      }));
     }
-    return {
-      role: msg.role === "assistant" ? "assistant" : msg.role,
-      content: toOpenAIContent(msg.content),
-      name: undefined
-    };
+    return res;
   });
 }
 function normalizeOpenAIProviderResponse(payload, request) {
@@ -3817,13 +3869,53 @@ class VertexProviderAdapter {
   toVertexTools(tools) {
     if (!tools?.length)
       return;
+    function flattenJsonSchema(schema) {
+      if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+        return schema;
+      }
+      const obj = { ...schema };
+      const definitions = obj.definitions;
+      delete obj.definitions;
+      function resolveRef(target, path4) {
+        if (!target || typeof target !== "object" || Array.isArray(target)) {
+          return target;
+        }
+        const copy = { ...target };
+        for (const key in copy) {
+          const value = copy[key];
+          if (key === "$ref" && typeof value === "string" && value.startsWith("#/definitions/")) {
+            const defName = value.slice(14);
+            const definition = definitions?.[defName];
+            if (definition) {
+              delete copy.$ref;
+              const resolved = resolveRef(definition, [...path4, defName]);
+              if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+                Object.assign(copy, resolved);
+              }
+            }
+          } else if (key === "$ref" && typeof value === "string") {
+            delete copy.$ref;
+          } else {
+            copy[key] = resolveRef(value, path4);
+          }
+        }
+        return copy;
+      }
+      return resolveRef(obj, []);
+    }
     return [
       {
-        functionDeclarations: tools.map((tool) => ({
-          name: tool.name,
-          description: tool.description,
-          parameters: tool.parameters
-        }))
+        functionDeclarations: tools.map((tool) => {
+          let parameters = tool.parameters;
+          if (parameters && typeof parameters === "object" && !Array.isArray(parameters)) {
+            parameters = flattenJsonSchema(parameters);
+          }
+          return {
+            name: tool.name,
+            description: tool.description,
+            parameters
+          };
+        })
       }
     ];
   }
@@ -5471,16 +5563,16 @@ async function createLiveStoreRuntime(options) {
       const clauses = [];
       const params = { limit };
       if (checkpoint.timestamp) {
-        clauses.push("(timestamp > $ts OR (timestamp = $ts AND numeric_id > $id))");
+        clauses.push("(timestamp < $ts OR (timestamp = $ts AND numeric_id < $id))");
         params.ts = checkpoint.timestamp;
-        params.id = checkpoint.id ?? 0;
+        params.id = checkpoint.id ?? Number.MAX_SAFE_INTEGER;
       }
       const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
       const rows = store.query({
         query: `
           SELECT * FROM logs
           ${where}
-          ORDER BY timestamp, numeric_id
+          ORDER BY timestamp DESC, numeric_id DESC
           LIMIT $limit
         `,
         bindValues: params
@@ -5501,6 +5593,29 @@ async function createLiveStoreRuntime(options) {
         return;
       return { timestamp: latest.timestamp, id: latest.numeric_id };
     },
+    async trim(maxRecords) {
+      const countResult = store.query({
+        query: `SELECT COUNT(*) as count FROM logs`,
+        bindValues: {}
+      });
+      const currentCount = countResult[0]?.count ?? 0;
+      if (currentCount <= maxRecords)
+        return 0;
+      const toDelete = currentCount - maxRecords;
+      const deleteResult = store.query({
+        query: `
+          DELETE FROM logs
+          WHERE id IN (
+            SELECT id FROM logs
+            ORDER BY timestamp ASC, numeric_id ASC
+            LIMIT @limit
+          )
+          RETURNING COUNT(*) as deleted
+        `,
+        bindValues: { limit: toDelete }
+      });
+      return deleteResult[0]?.deleted ?? 0;
+    },
     async close() {
       await store.shutdown();
     }
@@ -5548,6 +5663,21 @@ async function createServer(config) {
       batchSize: config.livestore.batchSize
     });
     logger.info({ seeded }, "Seeded LiveStore log mirror");
+    if (config.livestore.maxRecords && config.livestore.maxRecords > 0) {
+      const trimInterval = setInterval(async () => {
+        try {
+          const deleted = await liveStoreRuntime.trim(config.livestore.maxRecords);
+          if (deleted > 0) {
+            logger.debug({ deleted, maxRecords: config.livestore.maxRecords }, "LiveStore trimmed old records");
+          }
+        } catch (error) {
+          logger.error({ err: error }, "Failed to trim LiveStore records");
+        }
+      }, 30000);
+      server.addHook("onClose", async () => {
+        clearInterval(trimInterval);
+      });
+    }
     server.addHook("onClose", async () => {
       await liveStoreRuntime.close();
     });
@@ -5774,6 +5904,31 @@ async function createServer(config) {
       timestamp: meta.timestamp
     });
   });
+  server.get("/api/config", (_req, reply) => {
+    reply.send({
+      blobRoot: config.logging.blobRoot
+    });
+  });
+  server.get("/api/logs/:id/path", (req, reply) => {
+    const { id } = req.params;
+    const meta = logStore.readMetadata(Number(id));
+    if (!meta) {
+      reply.status(404).send({ error: { message: "Log not found" } });
+      return;
+    }
+    const date = new Date(meta.timestamp);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const dirPath = `${config.logging.blobRoot}/${year}/${month}/${day}/${meta.request_id}/`;
+    reply.send({
+      directory: dirPath,
+      request: meta.request_path ? `${config.logging.blobRoot}/${meta.request_path}` : null,
+      response: meta.response_path ? `${config.logging.blobRoot}/${meta.response_path}` : null,
+      providerRequest: meta.provider_request_path ? `${config.logging.blobRoot}/${meta.provider_request_path}` : null,
+      providerResponse: meta.provider_response_path ? `${config.logging.blobRoot}/${meta.provider_response_path}` : null
+    });
+  });
   return server;
 }
 async function handleRequest(req, reply, body, modelRegistry, pipeline, logStore, liveStoreRuntime, config, options) {
@@ -6045,5 +6200,5 @@ async function bootstrap() {
 }
 bootstrap();
 
-//# debugId=49E2D016D6E3465664756E2164756E21
+//# debugId=BB1E97A73BB51B4864756E2164756E21
 //# sourceMappingURL=index.js.map