@bman654/clodex 1.0.2 → 1.0.4

package/dist/cli.js

@@ -202,7 +202,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "1.0.2",
+  version: "1.0.4",
   publishConfig: {
     access: "public"
   },
@@ -7092,13 +7092,24 @@ function translateMessages(messages, npm, openAiPromptCacheBreakpoints = false)
   }
   return out;
 }
-function stripNullInputs(input) {
+function sanitizeToolInput(input, requiredProps) {
   const out = {};
   for (const [k, v] of Object.entries(input)) {
-    if (v !== null) out[k] = v;
+    if (v === null) continue;
+    if (Array.isArray(v) && v.length === 0 && !requiredProps?.has(k)) continue;
+    out[k] = v;
   }
   return out;
 }
+function toolRequiredProps(tools) {
+  const map = /* @__PURE__ */ new Map();
+  for (const [name, t] of Object.entries(tools ?? {})) {
+    const schema = t.inputSchema?.jsonSchema;
+    const required = Array.isArray(schema?.required) ? schema.required : [];
+    map.set(name, new Set(required.filter((r) => typeof r === "string")));
+  }
+  return map;
+}
 function translateTools(anthropicTools) {
   if (!anthropicTools?.length) return void 0;
   const tools = {};
@@ -7208,13 +7219,17 @@ function forwardAbortSignal(source, target) {
   source.addEventListener("abort", forward, { once: true });
   return () => source.removeEventListener("abort", forward);
 }
-async function writeAnthropicStream(stream, modelId, write, log12, observer) {
+async function writeAnthropicStream(stream, modelId, write, log12, observer, tools) {
   const messageId = "msg_" + Date.now();
+  const requiredProps = toolRequiredProps(tools);
   let blockIndex = -1;
   let started = false;
   let openType = null;
   let pendingThinkingSig;
   const idToBlock = /* @__PURE__ */ new Map();
+  const toolJsonBuffer = /* @__PURE__ */ new Map();
+  const flushedTools = /* @__PURE__ */ new Set();
+  let openToolId = null;
   let finishReason = "end_turn";
   let usage = {
     input_tokens: 0,
@@ -7254,8 +7269,20 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer) {
       });
       pendingThinkingSig = void 0;
     }
+    if (openType === "tool" && openToolId !== null && !flushedTools.has(openToolId)) {
+      const buffered = toolJsonBuffer.get(openToolId);
+      if (buffered) {
+        emit("content_block_delta", {
+          type: "content_block_delta",
+          index: blockIndex,
+          delta: { type: "input_json_delta", partial_json: buffered }
+        });
+      }
+      flushedTools.add(openToolId);
+    }
     if (openType) emit("content_block_stop", { type: "content_block_stop", index: blockIndex });
     openType = null;
+    openToolId = null;
   };
   const openBlock = (type, contentBlock) => {
     ensureStart();
@@ -7317,32 +7344,45 @@ async function writeAnthropicStream(stream, modelId, write, log12, observer) {
           input: {}
         });
         idToBlock.set(part.id ?? "", blockIndex);
+        openToolId = part.id ?? "";
         break;
       }
-      case "tool-input-delta":
-        emit("content_block_delta", {
-          type: "content_block_delta",
-          index: idToBlock.get(part.id ?? "") ?? blockIndex,
-          delta: { type: "input_json_delta", partial_json: part.delta ?? part.text ?? "" }
-        });
+      case "tool-input-delta": {
+        const id = part.id ?? "";
+        toolJsonBuffer.set(id, (toolJsonBuffer.get(id) ?? "") + (part.delta ?? part.text ?? ""));
         break;
+      }
       case "tool-input-end":
         break;
       case "tool-call": {
         finishReason = "tool_use";
-        if (!idToBlock.has(part.toolCallId ?? "") && openType !== "tool") {
+        const id = part.toolCallId ?? "";
+        if (idToBlock.has(id)) {
+          if (!flushedTools.has(id)) {
+            const json = part.input !== void 0 && part.input !== null ? JSON.stringify(sanitizeToolInput(part.input, requiredProps.get(part.toolName ?? ""))) : toolJsonBuffer.get(id) ?? "";
+            if (json) {
+              emit("content_block_delta", {
+                type: "content_block_delta",
+                index: idToBlock.get(id) ?? blockIndex,
+                delta: { type: "input_json_delta", partial_json: json }
+              });
+            }
+            flushedTools.add(id);
+          }
+        } else if (openType !== "tool") {
           const sig = grabRoundTripSignature(part);
           openBlock("tool", {
             type: "tool_use",
-            id: encodeToolUseId(part.toolCallId ?? "", sig),
+            id: encodeToolUseId(id, sig),
             name: part.toolName,
             input: {}
           });
           emit("content_block_delta", {
             type: "content_block_delta",
             index: blockIndex,
-            delta: { type: "input_json_delta", partial_json: JSON.stringify(stripNullInputs(part.input ?? {})) }
+            delta: { type: "input_json_delta", partial_json: JSON.stringify(sanitizeToolInput(part.input ?? {}, requiredProps.get(part.toolName ?? ""))) }
           });
+          flushedTools.add(id);
         }
         break;
       }
@@ -7407,7 +7447,7 @@ async function streamAnthropicResponse(model, params, modelId, write, log12, obs
     }
   })();
   try {
-    await writeAnthropicStream(watchedStream, modelId, write, log12, { ...observer, abortSignal });
+    await writeAnthropicStream(watchedStream, modelId, write, log12, { ...observer, abortSignal }, params.tools);
   } finally {
     stopForwardingAbort();
     clearTimeout(idleTimer);
@@ -7498,6 +7538,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
       if (!generateAbort.signal.aborted) generateAbort.abort();
     }
   }
+  const requiredProps = toolRequiredProps(params.tools);
   return {
     id: "msg_" + Date.now(),
     type: "message",
@@ -7509,7 +7550,7 @@ async function generateAnthropicResponse(model, params, modelId, options) {
         type: "tool_use",
         id: encodeToolUseId(tc.toolCallId, grabRoundTripSignature(tc)),
         name: tc.toolName,
-        input: stripNullInputs(tc.input)
+        input: sanitizeToolInput(tc.input ?? {}, requiredProps.get(tc.toolName))
       }))
     ],
     stop_reason: finishReason === "tool-calls" ? "tool_use" : "end_turn",
@@ -7558,6 +7599,8 @@ function anthropicPromptTooLongMessage(body, contextWindow) {
 }
 
 // src/proxy.ts
+var STREAM_KEEPALIVE_INTERVAL_MS = 2e4;
+var STREAM_KEEPALIVE_PING = 'event: ping\ndata: {"type":"ping"}\n\n';
 function createTranslationLifecycle(logPath, requestId, modelId, provider) {
   if (!logPath || !requestId) return void 0;
   const startedAt = Date.now();
@@ -7901,6 +7944,9 @@ function startProxyCatalog(routes, defaultAliasId, debug = false, inferenceLogPa
           });
           translationLifecycle?.dispatched();
           if (clientWantsStream) {
+            const keepAliveMs = Number(process.env.CLODEX_STREAM_KEEPALIVE_INTERVAL_MS) || STREAM_KEEPALIVE_INTERVAL_MS;
+            let lastDownstreamWriteAt = Date.now();
+            let lastUpstreamPartAt = Date.now();
             const writeStreamChunk = (chunk) => {
               translationLifecycle?.onOutput(chunk);
               if (!res.headersSent) {
@@ -7910,23 +7956,43 @@ function startProxyCatalog(routes, defaultAliasId, debug = false, inferenceLogPa
                   "Connection": "keep-alive"
                 });
               }
+              lastDownstreamWriteAt = Date.now();
               res.write(chunk);
             };
-            await withResponsesWebSocketDiagnosticContext(
-              { requestId: relayRequestId, claudeSessionId },
-              () => streamAnthropicResponse(
-                model,
-                params,
-                originalModel,
-                writeStreamChunk,
-                plog,
-                {
-                  onPart: (partType) => translationLifecycle?.onPart(partType),
-                  initialInputTokens: estimateAnthropicInputTokens(anthropicBody),
-                  abortSignal: clientAbort.signal
-                }
-              )
-            );
+            const keepAlive = setInterval(() => {
+              if (res.writableEnded || !res.headersSent) return;
+              const now = Date.now();
+              const outputIdleMs = now - lastDownstreamWriteAt;
+              const upstreamIdleMs = now - lastUpstreamPartAt;
+              if (outputIdleMs >= keepAliveMs && upstreamIdleMs < keepAliveMs) {
+                lastDownstreamWriteAt = now;
+                res.write(STREAM_KEEPALIVE_PING);
+                plog(() => `stream keepalive ping: output idle ${outputIdleMs}ms, upstream active (${upstreamIdleMs}ms since last part)`);
+              }
+            }, keepAliveMs);
+            keepAlive.unref();
+            try {
+              await withResponsesWebSocketDiagnosticContext(
+                { requestId: relayRequestId, claudeSessionId },
+                () => streamAnthropicResponse(
+                  model,
+                  params,
+                  originalModel,
+                  writeStreamChunk,
+                  plog,
+                  {
+                    onPart: (partType) => {
+                      lastUpstreamPartAt = Date.now();
+                      translationLifecycle?.onPart(partType);
+                    },
+                    initialInputTokens: estimateAnthropicInputTokens(anthropicBody),
+                    abortSignal: clientAbort.signal
+                  }
+                )
+              );
+            } finally {
+              clearInterval(keepAlive);
+            }
             translationLifecycle?.complete();
             if (!res.headersSent) writeStreamChunk("");
             res.end();