clawmux 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -1,4 +1,27 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -77,6 +100,13 @@ async function writeWebResponse(res, response) {
   }
 }
 
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  bootstrap: () => bootstrap
+});
+module.exports = __toCommonJS(exports_src);
+
 // src/proxy/router.ts
 var VERSION = "0.1.0";
 function jsonResponse(body, status = 200) {
@@ -579,14 +609,7 @@ function getAuthProfilesPath(agentId) {
   const id = agentId ?? "main";
   return import_node_path2.join(getHomeDir(), ".openclaw", "agents", id, "agent", "auth-profiles.json");
 }
-async function readAuthProfiles(agentId, profilesPath) {
-  const path = profilesPath ?? getAuthProfilesPath(agentId);
-  let text;
-  try {
-    text = await import_promises4.readFile(path, "utf-8");
-  } catch {
-    return [];
-  }
+function parseAuthProfilesFile(text) {
   try {
     const parsed = JSON.parse(text);
     if (Array.isArray(parsed))
@@ -594,7 +617,7 @@ async function readAuthProfiles(agentId, profilesPath) {
     if (parsed && typeof parsed === "object" && parsed.profiles) {
       return Object.entries(parsed.profiles).map(([key, profile]) => ({
         provider: profile.provider ?? key.split(":")[0],
-        apiKey: profile.access ?? profile.apiKey,
+        apiKey: profile.access ?? profile.apiKey ?? profile.key,
         token: profile.token
       })).filter((p) => {
         const token = p.apiKey ?? p.token;
@@ -617,6 +640,33 @@ async function readAuthProfiles(agentId, profilesPath) {
     throw new Error(`Failed to parse auth-profiles.json: ${message}`);
   }
 }
+async function readAuthProfiles(_agentId, _profilesPath, agentsDirOverride) {
+  const agentsDir = agentsDirOverride ?? import_node_path2.join(getHomeDir(), ".openclaw", "agents");
+  let agentDirs;
+  try {
+    agentDirs = (await import_promises4.readdir(agentsDir, { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    const path = getAuthProfilesPath(_agentId);
+    try {
+      return parseAuthProfilesFile(await import_promises4.readFile(path, "utf-8"));
+    } catch {
+      return [];
+    }
+  }
+  const ordered = ["main", ...agentDirs.filter((d) => d !== "main")];
+  const merged = new Map;
+  for (const agentId of ordered) {
+    const profilePath = import_node_path2.join(agentsDir, agentId, "agent", "auth-profiles.json");
+    try {
+      const text = await import_promises4.readFile(profilePath, "utf-8");
+      const profiles = parseAuthProfilesFile(text);
+      for (const p of profiles) {
+        merged.set(p.provider, p);
+      }
+    } catch {}
+  }
+  return Array.from(merged.values());
+}
 function getProviderConfig(provider, config) {
   return config.models?.providers?.[provider];
 }
@@ -765,6 +815,38 @@ function getAdapter(apiType) {
   return adapters.get(apiType);
 }
 
+// src/adapters/tool-converter.ts
+function toOpenAITools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0)
+    return;
+  return tools.map((tool) => {
+    if (tool.type === "function" && tool.function)
+      return tool;
+    return {
+      type: "function",
+      function: {
+        name: tool.name ?? "",
+        description: tool.description ?? "",
+        parameters: tool.input_schema ?? tool.parameters ?? { type: "object", properties: {} }
+      }
+    };
+  });
+}
+function toAnthropicTools(tools) {
+  if (!Array.isArray(tools) || tools.length === 0)
+    return;
+  return tools.map((tool) => {
+    if (tool.input_schema && !tool.type)
+      return tool;
+    const fn = tool.function ?? tool;
+    return {
+      name: fn.name ?? "",
+      description: fn.description ?? "",
+      input_schema: fn.parameters ?? { type: "object", properties: {} }
+    };
+  });
+}
+
 // src/adapters/anthropic.ts
 class AnthropicAdapter {
   apiType = "anthropic-messages";
@@ -791,18 +873,42 @@ class AnthropicAdapter {
       "anthropic-version": "2023-06-01",
       "content-type": "application/json"
     };
-    let bodyObj = {
-      ...parsed.rawBody,
-      model: targetModel
-    };
     const isHaiku = targetModel.toLowerCase().includes("haiku");
     const hasThinking = "thinking" in parsed.rawBody;
     if (hasThinking && !isHaiku) {
       headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
     }
-    if (isHaiku && "thinking" in bodyObj) {
-      const { thinking: _, ...rest } = bodyObj;
-      bodyObj = rest;
+    const ANTHROPIC_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "top_k",
+      "stop_sequences",
+      "metadata",
+      "service_tier"
+    ];
+    const samplingParams = {};
+    for (const key of ANTHROPIC_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
+    let bodyObj = {
+      model: targetModel,
+      messages: parsed.messages,
+      stream: parsed.stream,
+      ...samplingParams
+    };
+    if (parsed.system !== undefined) {
+      bodyObj.system = parsed.system;
+    }
+    if (parsed.maxTokens !== undefined) {
+      bodyObj.max_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      bodyObj.tools = toAnthropicTools(parsed.rawBody.tools);
+    }
+    if (!isHaiku && hasThinking) {
+      bodyObj.thinking = parsed.rawBody.thinking;
     }
     return {
       url,
@@ -1069,11 +1175,43 @@ class OpenAICompletionsAdapter {
     return parseOpenAIBody(body);
   }
   buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
-    const { rawBody } = parsed;
+    const messages = [];
+    if (parsed.system !== undefined) {
+      messages.push({ role: "system", content: parsed.system });
+    }
+    messages.push(...parsed.messages);
+    const OPENAI_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "frequency_penalty",
+      "presence_penalty",
+      "logprobs",
+      "top_logprobs",
+      "seed",
+      "stop",
+      "n",
+      "logit_bias",
+      "response_format",
+      "reasoning_effort"
+    ];
+    const samplingParams = {};
+    for (const key of OPENAI_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
     const upstreamBody = {
-      ...rawBody,
-      model: targetModel
+      model: targetModel,
+      messages,
+      stream: parsed.stream,
+      ...samplingParams
     };
+    if (parsed.maxTokens !== undefined) {
+      upstreamBody.max_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      upstreamBody.tools = toOpenAITools(parsed.rawBody.tools);
+    }
     return {
       url: /\/v\d+\/?$/.test(baseUrl) ? `${baseUrl.replace(/\/$/, "")}/chat/completions` : `${baseUrl}/v1/chat/completions`,
       method: "POST",
@@ -1100,8 +1238,11 @@ class OpenAICompletionsAdapter {
     if (Array.isArray(choices) && choices.length > 0) {
       const choice = choices[0];
       const message = choice.message;
-      if (message && typeof message.content === "string") {
-        content = message.content;
+      if (message) {
+        const messageText = message.content ?? message.reasoning_content;
+        if (typeof messageText === "string") {
+          content = messageText;
+        }
       }
       if (typeof choice.finish_reason === "string") {
         stopReason = choice.finish_reason;
@@ -1171,16 +1312,17 @@ class OpenAICompletionsAdapter {
       const choice = choices[0];
       const delta = choice.delta;
       const finishReason = choice.finish_reason;
-      if (delta?.role === "assistant" && !delta.content) {
+      const textContent = delta?.content ?? delta?.reasoning_content;
+      if (delta?.role === "assistant" && textContent == null) {
         events.push({
           type: "message_start",
           id: String(data.id ?? ""),
           model: String(data.model ?? "")
         });
-      } else if (typeof delta?.content === "string") {
+      } else if (typeof textContent === "string") {
         events.push({
           type: "content_delta",
-          text: delta.content,
+          text: textContent,
           index: typeof choice.index === "number" ? choice.index : 0
         });
       }
@@ -1212,7 +1354,7 @@ class OpenAICompletionsAdapter {
           choices: [
             {
               index: 0,
-              delta: { role: "assistant", content: "" },
+              delta: { role: "assistant" },
               finish_reason: null
             }
           ]
@@ -1272,11 +1414,40 @@ class OpenAIResponsesAdapter {
     return parseOpenAIBody(body);
   }
   buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
-    const { rawBody } = parsed;
+    const input = [];
+    if (parsed.system !== undefined) {
+      input.push({ role: "system", content: parsed.system });
+    }
+    input.push(...parsed.messages);
+    const OPENAI_RESPONSES_SAMPLING_KEYS = [
+      "temperature",
+      "top_p",
+      "truncation",
+      "reasoning",
+      "reasoning_effort",
+      "text",
+      "metadata",
+      "store",
+      "include"
+    ];
+    const samplingParams = {};
+    for (const key of OPENAI_RESPONSES_SAMPLING_KEYS) {
+      if (key in parsed.rawBody) {
+        samplingParams[key] = parsed.rawBody[key];
+      }
+    }
     const upstreamBody = {
-      ...rawBody,
-      model: targetModel
+      model: targetModel,
+      input,
+      stream: parsed.stream,
+      ...samplingParams
     };
+    if (parsed.maxTokens !== undefined) {
+      upstreamBody.max_output_tokens = parsed.maxTokens;
+    }
+    if (parsed.rawBody.tools) {
+      upstreamBody.tools = toOpenAITools(parsed.rawBody.tools);
+    }
     return {
       url: `${baseUrl}/v1/responses`,
       method: "POST",
@@ -2285,6 +2456,9 @@ class OpenAICodexAdapter {
     }
     delete upstreamBody.max_tokens;
     delete upstreamBody.max_output_tokens;
+    if (upstreamBody.tools) {
+      upstreamBody.tools = toOpenAITools(upstreamBody.tools);
+    }
     return {
       url: `${baseUrl}/codex/responses`,
       method: "POST",
@@ -2941,6 +3115,7 @@ function createStreamTranslator(sourceAdapter, targetAdapter) {
     return new TransformStream;
   }
   let buffer = "";
+  let messageStarted = false;
   return new TransformStream({
     transform(chunk, controller) {
       if (!sourceAdapter.parseStreamChunk || !targetAdapter.buildStreamChunk) {
@@ -2958,6 +3133,18 @@ function createStreamTranslator(sourceAdapter, targetAdapter) {
           continue;
         const events = sourceAdapter.parseStreamChunk(frame);
         for (const event of events) {
+          if (event.type === "message_start") {
+            messageStarted = true;
+          } else if (!messageStarted && (event.type === "content_delta" || event.type === "content_stop")) {
+            messageStarted = true;
+            const synthetic = targetAdapter.buildStreamChunk({
+              type: "message_start",
+              id: "",
+              model: ""
+            });
+            if (synthetic)
+              controller.enqueue(encoder.encode(synthetic));
+          }
           const translated = targetAdapter.buildStreamChunk(event);
           controller.enqueue(encoder.encode(translated));
         }
@@ -2967,6 +3154,18 @@ function createStreamTranslator(sourceAdapter, targetAdapter) {
       if (buffer.trim() !== "" && sourceAdapter.parseStreamChunk && targetAdapter.buildStreamChunk) {
         const events = sourceAdapter.parseStreamChunk(buffer);
         for (const event of events) {
+          if (event.type === "message_start") {
+            messageStarted = true;
+          } else if (!messageStarted && (event.type === "content_delta" || event.type === "content_stop")) {
+            messageStarted = true;
+            const synthetic = targetAdapter.buildStreamChunk({
+              type: "message_start",
+              id: "",
+              model: ""
+            });
+            if (synthetic)
+              controller.enqueue(encoder.encode(synthetic));
+          }
           const translated = targetAdapter.buildStreamChunk(event);
           controller.enqueue(encoder.encode(translated));
         }
@@ -3658,7 +3857,7 @@ function setupPipelineRoutes(config, openclawConfig, authProfiles, compressionMi
 
 // src/index.ts
 var import_node_path4 = require("node:path");
-async function bootstrap() {
+async function bootstrap(portOverride) {
   const configPath = process.env.CLAWMUX_CONFIG ? import_node_path4.resolve(process.env.CLAWMUX_CONFIG) : import_node_path4.resolve(process.cwd(), "clawmux.json");
   const result = await loadConfig(configPath);
   if (!result.valid) {
@@ -3673,7 +3872,7 @@ async function bootstrap() {
   const piAiCatalog = await loadPiAiCatalog();
   const compressionMiddleware = createResolvedCompressionMiddleware(config, openclawConfig, piAiCatalog);
   setupPipelineRoutes(config, openclawConfig, authProfiles, compressionMiddleware);
-  const port = parseInt(process.env.CLAWMUX_PORT ?? "3456", 10);
+  const port = portOverride ?? parseInt(process.env.CLAWMUX_PORT ?? "3456", 10);
   const server = createServer({ port, host: "127.0.0.1" });
   server.start();
   console.log(`[clawmux] Proxy server running on http://127.0.0.1:${port}`);
@@ -3685,7 +3884,9 @@ async function bootstrap() {
   });
   watcher.start();
 }
-bootstrap().catch((err) => {
-  console.error(`[clawmux] Fatal: ${err.message}`);
-  process.exit(1);
-});
+if (require.main == module || typeof Bun !== "undefined" && Bun.main === "/home/runner/work/ClawMux/ClawMux/src/index.ts") {
+  bootstrap().catch((err) => {
+    console.error(`[clawmux] Fatal: ${err.message}`);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmux",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Smart model routing + context compression proxy for OpenClaw",
   "type": "module",
   "bin": {