clawmux 0.2.3 → 0.3.0

package/dist/cli.cjs

@@ -317,7 +317,7 @@ function getLogDir() {
 }
 
 // src/cli.ts
-var VERSION2 = process.env.npm_package_version ?? "0.2.3";
+var VERSION2 = process.env.npm_package_version ?? "0.3.0";
 var SERVICE_NAME = "clawmux";
 var HELP = `Usage: clawmux <command>
 

package/dist/index.cjs

@@ -596,7 +596,20 @@ async function readAuthProfiles(agentId, profilesPath) {
         provider: profile.provider ?? key.split(":")[0],
         apiKey: profile.access ?? profile.apiKey,
         token: profile.token
-      }));
+      })).filter((p) => {
+        const token = p.apiKey ?? p.token;
+        if (!token || !token.includes("."))
+          return true;
+        try {
+          const payload = token.split(".")[1];
+          const decoded = JSON.parse(Buffer.from(payload, "base64").toString());
+          if (decoded.exp && decoded.exp * 1000 < Date.now())
+            return false;
+        } catch (_) {
+          return true;
+        }
+        return true;
+      });
     }
     return [];
   } catch (err) {
@@ -2250,6 +2263,57 @@ ${JSON.stringify({
 var bedrockAdapter = new BedrockAdapter;
 registerAdapter(bedrockAdapter);
 
+// src/adapters/openai-codex.ts
+class OpenAICodexAdapter {
+  apiType = "openai-codex-responses";
+  parseRequest(body) {
+    return parseOpenAIBody(body);
+  }
+  buildUpstreamRequest(parsed, targetModel, baseUrl, auth) {
+    const { rawBody } = parsed;
+    const upstreamBody = { ...rawBody };
+    upstreamBody.model = targetModel;
+    upstreamBody.stream = true;
+    upstreamBody.store = false;
+    if (!upstreamBody.instructions) {
+      upstreamBody.instructions = upstreamBody.system ?? "You are a helpful assistant.";
+    }
+    delete upstreamBody.system;
+    if (!upstreamBody.input && upstreamBody.messages) {
+      upstreamBody.input = upstreamBody.messages;
+      delete upstreamBody.messages;
+    }
+    delete upstreamBody.max_tokens;
+    delete upstreamBody.max_output_tokens;
+    return {
+      url: `${baseUrl}/codex/responses`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${auth.apiKey}`
+      },
+      body: JSON.stringify(upstreamBody)
+    };
+  }
+  modifyMessages(rawBody, compressedMessages) {
+    return openaiResponsesAdapter.modifyMessages(rawBody, compressedMessages);
+  }
+  parseResponse(body) {
+    return openaiResponsesAdapter.parseResponse(body);
+  }
+  buildResponse(parsed) {
+    return openaiResponsesAdapter.buildResponse(parsed);
+  }
+  parseStreamChunk(chunk) {
+    return openaiResponsesAdapter.parseStreamChunk(chunk);
+  }
+  buildStreamChunk(event) {
+    return openaiResponsesAdapter.buildStreamChunk(event);
+  }
+}
+var openaiCodexAdapter = new OpenAICodexAdapter;
+registerAdapter(openaiCodexAdapter);
+
 // src/compression/compaction-detector.ts
 var COMPACTION_PATTERNS = [
   "merge these partial summaries into a single cohesive summary",
@@ -3386,6 +3450,48 @@ function createCompressionMiddleware(config) {
 
 // src/proxy/pipeline.ts
 registerAdapter(new AnthropicAdapter);
+async function collectCodexStream(sourceAdapter, response) {
+  const reader = response.body.getReader();
+  const decoder2 = new TextDecoder;
+  let buffer = "";
+  let id = "";
+  let model = "";
+  const textParts = [];
+  let usage;
+  for (;; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    buffer += decoder2.decode(value, { stream: true });
+    let idx;
+    while ((idx = buffer.indexOf(`
+
+`)) !== -1) {
+      const frame = buffer.slice(0, idx);
+      buffer = buffer.slice(idx + 2);
+      if (!frame.trim() || !sourceAdapter.parseStreamChunk)
+        continue;
+      for (const event of sourceAdapter.parseStreamChunk(frame)) {
+        if (event.type === "message_start") {
+          id = event.id ?? "";
+          model = event.model ?? "";
+        } else if (event.type === "content_delta") {
+          textParts.push(event.text ?? "");
+        } else if (event.type === "message_stop" && event.usage) {
+          usage = event.usage;
+        }
+      }
+    }
+  }
+  return {
+    id,
+    model,
+    content: textParts.join(""),
+    role: "assistant",
+    stopReason: "completed",
+    usage
+  };
+}
 function findProviderForModel(modelString, openclawConfig) {
   const providers = openclawConfig.models?.providers;
   if (!providers)
@@ -3495,6 +3601,18 @@ async function handleApiRequest(req, body, apiType, config, openclawConfig, auth
   if (compressionMiddleware && upstreamResponse.ok) {
     compressionMiddleware.afterResponse(parsed, adapter, baseUrl, authInfo);
   }
+  const isCodexUpstream = targetApiType === "openai-codex-responses";
+  if (isCodexUpstream && upstreamResponse.ok && upstreamResponse.body) {
+    if (effectiveParsed.stream) {
+      return translateResponse(requestAdapter, adapter, upstreamResponse, true);
+    }
+    const collected = await collectCodexStream(requestAdapter, upstreamResponse);
+    const translated = adapter.buildResponse(collected);
+    return new Response(JSON.stringify(translated), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
   if (targetAdapter && upstreamResponse.ok) {
     return translateResponse(targetAdapter, adapter, upstreamResponse, effectiveParsed.stream);
   }

package/package.json

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