glmproxy 2.6.1 → 2.7.0

package/README.md

@@ -250,6 +250,9 @@ glmproxy --test-models
 | `PREFER_LOCAL` | off | Set to `1` to use the local AutoClaw gateway first, skipping cloud attempts |
 | `TRUSTED_PROXIES` | empty | Comma-separated IPs whose `X-Forwarded-For` header is trusted for rate limiting |
 | `MAX_BODY_BYTES` | `52428800` | Max request body (50 MB) |
+| `MAX_MESSAGE_TEXT_BYTES` | `262144` | Max per-message TEXT size (256 KB; base64 image data is not counted as text) |
+| `MAX_TOTAL_MESSAGE_TEXT_BYTES` | `1048576` | Max combined message text (1 MB) |
+| `MAX_IMAGE_BYTES` | `20971520` | Max decoded size per image attachment (20 MB) |
 | `JSONL_LOG` | off | Write structured JSONL request log when `true` (also on with `LOG_LEVEL=debug`) |
 | `JSONL_FILE` | `proxy_requests.jsonl` (Anthropic: `proxy_requests_anthropic.jsonl`) | JSONL output path |
 | `JSONL_SYNC` | off | Write JSONL lines synchronously when `true` (flush every line) |
@@ -264,6 +267,7 @@ glmproxy --test-models
 | `--limit [n]` | — | Set or clear the max message/entity limit (e.g. `--limit 256`; bare `--limit` prints the current value) |
 | `--doctor` | — | Scan AutoClaw's current runtime model catalog and show Anthropic routing |
 | `--test-models` / `--test` | — | Live health check: test every catalog model through the full pipeline |
+| `--stop` | — | Kill any other running glmproxy instances (npm-global or `bin/cli.js` starts) and exit |
 | `--help`, `-h` | — | Show CLI help |
 
 **JSONL request logging.** Set `JSONL_LOG=true` (or `LOG_LEVEL=debug`) to write one JSON line per request:
@@ -387,6 +391,7 @@ TRUSTED_PROXIES=127.0.0.1 glmproxy --host 0.0.0.0
 - Upstream 400 `"invalid request"` gets one retry after a 2s delay (a known upstream hiccup). Quota/plan errors are never retried
 - The cloud upstream requires AutoClaw's app system-prompt banner in every request. The proxy injects it automatically and never duplicates it. In practice it doesn't change much since your harness's own system prompt overrides it anyway
 - Max output is clamped to each model's real upstream cap (131K for every GLM model, 393K for DeepSeek). AutoClaw's runtime catalog overstates GLM-5.3's cap (307K), and asking the cloud for more than a model's real cap makes it **silently run a DeepSeek model instead and bill DeepSeek credits** — the proxy clamps so your `zai_glm-5.3` stays GLM-5.3
+- Images pass through natively: pasted/attached images (`image_url` data URLs, Anthropic `image` blocks) reach vision-capable models (e.g. `zai_glm-5.3-flash`) as real image parts — the model sees them directly, no OCR bridge. Text-only models reject them upstream and the request falls back to the desktop agent, mirroring AutoClaw's own gating
 - The token file is watched for changes, so AutoClaw can rotate auth mid-session without a restart
 - AutoClaw's client identity (app version, platform, channel) loads dynamically from its runtime file, same as the model catalog, so an AutoClaw app update is picked up without editing or restarting the proxy
 - The fallback model catalog lives in `lib/fallback-models.json` (override with `FALLBACK_MODELS_PATH`). The built-in list is only a last resort when AutoClaw's runtime file is unreadable

package/anthropic.js

@@ -113,11 +113,26 @@ function anthropicToOpenAI(body, modelId) {
     const toolResults = [];
     const toolUses = [];
     const textParts = [];
+    const imageParts = [];
+
+    // Anthropic image block → OpenAI image_url part (AutoClaw's cloud accepts
+    // native vision parts on the chat/completions wire; probe-verified 2026-09-04).
+    const toOpenAIImage = (block) => {
+      const src = block?.source;
+      if (src?.type === "base64" && typeof src.data === "string") {
+        return { type: "image_url", image_url: { url: `data:${src.media_type || "image/png"};base64,${src.data}` } };
+      }
+      if (src?.type === "url" && typeof src.url === "string") {
+        return { type: "image_url", image_url: { url: src.url } };
+      }
+      return null;
+    };
 
     for (const block of content) {
       if (block.type === "tool_result")      toolResults.push(block);
       else if (block.type === "tool_use")    toolUses.push(block);
       else if (block.type === "text")        textParts.push(block.text);
+      else if (block.type === "image")       { const p = toOpenAIImage(block); if (p) imageParts.push(p); }
       else if (block.type === "thinking")    { /* skip */ }
     }
 
@@ -149,6 +164,13 @@ function anthropicToOpenAI(body, modelId) {
       };
       if (textParts.length > 0) msgObj.content = textParts.join("\n");
       messages.push(msgObj);
+    } else if (imageParts.length > 0 && msg.role !== "assistant") {
+      // Multimodal user turn: OpenAI array content with text + image parts.
+      const parts = [
+        ...textParts.map((t) => ({ type: "text", text: t })),
+        ...imageParts,
+      ];
+      messages.push({ role: msg.role, content: parts });
     } else if (textParts.length > 0) {
       messages.push({ role: msg.role, content: textParts.join("\n") });
     } else if (toolResults.length === 0 && toolUses.length === 0) {

package/bin/cli.js

@@ -5,6 +5,7 @@ import fs from "fs";
 import { fileURLToPath, pathToFileURL } from "url";
 import { promptSelect, promptInput, promptNumber } from "../lib/prompts.js";
 import http from "http";
+import { spawnSync } from "child_process";
 import {
   getModelCatalog, loadConfig, createTokenLayer,
   fetchRemoteModelConfig, annotateCreditTiers, resolveTierTargets,
@@ -15,7 +16,7 @@ import { DEFAULT_PORTS, DEFAULT_HOST, DEFAULT_PROXY_KEY, TEST_PROXY_PORT } from
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
 
-const FLAGS = ["--anthropic", "--openai", "--port", "--host", "--key", "--rate-limit", "--max-messages", "--doctor", "--test-models", "--test", "--limit", "--help", "-h"];
+const FLAGS = ["--anthropic", "--openai", "--port", "--host", "--key", "--rate-limit", "--max-messages", "--doctor", "--test-models", "--test", "--limit", "--stop", "--help", "-h"];
 
 // Current effective MAX_MESSAGES env value as a finite number, or Infinity.
 function effectiveMaxMessages() {
@@ -49,6 +50,7 @@ function showHelp() {
                           If you have a compression system, leaving this unlimited is preferred.
     --doctor              Live credit-tier scan of AutoClaw's catalog + routing map
     --test-models         Test all configured models against upstream and show live health
+    --stop                Kill any other running glmproxy instances and exit
     --limit               Set or clear the max entity / messages limit (own menu item)
     --help, -h            Show this help message
 
@@ -288,6 +290,70 @@ if (args.includes("--doctor")) {
   process.exit(0);
 }
 
+// ─── --stop / stop: kill other running glmproxy instances ───────────────────
+// Matches processes whose command line mentions glmproxy AND cli.js (covers
+// npm-global installs and repo checkouts started via bin/cli.js) while never
+// matching this very process. Dev entrypoints launched as `node openai.js`
+// carry no glmproxy marker — stop those by hand.
+function findGlmproxyInstances() {
+  const selfPid = process.pid;
+  const hits = [];
+  if (process.platform === "win32") {
+    const res = spawnSync("powershell", ["-NoProfile", "-Command",
+      `Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^node' -and $_.CommandLine -match 'glmproxy' -and $_.CommandLine -match 'cli\\.js' } | ForEach-Object { "$($_.ProcessId)|$($_.CommandLine)" }`,
+    ], { encoding: "utf8", windowsHide: true });
+    for (const line of (res.stdout || "").split(/\r?\n/)) {
+      const idx = line.indexOf("|");
+      if (idx <= 0) continue;
+      const pid = Number.parseInt(line.slice(0, idx), 10);
+      const cmd = line.slice(idx + 1);
+      if (Number.isInteger(pid) && pid > 0 && pid !== selfPid) hits.push({ pid, cmd });
+    }
+  } else {
+    const res = spawnSync("ps", ["-eo", "pid=,command="], { encoding: "utf8" });
+    for (const line of (res.stdout || "").split("\n")) {
+      const m = line.match(/^\s*(\d+)\s+(.+)$/);
+      if (!m) continue;
+      const pid = Number.parseInt(m[1], 10);
+      const cmd = m[2];
+      if (cmd.includes("glmproxy") && cmd.includes("cli.js") && pid !== selfPid) hits.push({ pid, cmd });
+    }
+  }
+  return hits;
+}
+
+function runStop() {
+  console.log(`\n  Looking for other glmproxy instances…`);
+  let hits = [];
+  try { hits = findGlmproxyInstances(); }
+  catch (e) { console.log(`  ${COLORS.RED}✗ scan failed: ${e.message}${COLORS.RESET}\n`); return; }
+
+  if (hits.length === 0) {
+    console.log(`  ${COLORS.GRAY}No other instances running.${COLORS.RESET}\n`);
+    return;
+  }
+
+  let killed = 0, failed = 0;
+  for (const { pid, cmd } of hits) {
+    const short = cmd.length > 96 ? `${cmd.slice(0, 96)}…` : cmd;
+    try {
+      process.kill(pid, "SIGTERM");
+      console.log(`  ${COLORS.GREEN}✓${COLORS.RESET} stopped PID ${pid} — ${short}`);
+      killed++;
+    } catch (e) {
+      console.log(`  ${COLORS.RED}✗${COLORS.RESET} PID ${pid} — ${e.code || e.message} — ${short}`);
+      failed++;
+    }
+  }
+  console.log(`\n  ${killed} instance(s) stopped${failed ? `, ${failed} failed` : ""}.\n`);
+}
+
+// --stop / stop: kill other running glmproxy instances, then exit.
+if (args.includes("--stop") || args[0] === "stop") {
+  runStop();
+  process.exit(0);
+}
+
 // --limit: set or clear the max entity / messages limit, then exit.
 if (args.includes("--limit")) {
   const limitIdx = args.indexOf("--limit");

package/lib/core.js

@@ -637,9 +637,19 @@ export function isAuthorized(req, proxyKey) {
 }
 
 export function validateChatPayload(body, maxMessages = Infinity) {
+  const envInt = (name, fallback) => {
+    const raw = process.env[name];
+    const n = raw ? Number.parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+  };
   const MAX_MESSAGES = (maxMessages && Number.isFinite(maxMessages)) ? maxMessages : Infinity;
-  const MAX_MESSAGE_TEXT_BYTES = 256 * 1024;
-  const MAX_TOTAL_MESSAGE_TEXT_BYTES = 1024 * 1024;
+  // Text caps guard against runaway harness spam. Image payloads (base64
+  // data URLs) are sized SEPARATELY — the cloud accepts native image_url
+  // parts and screenshots are legitimately large; counting base64 as text
+  // caused the 413 "an individual message is too large" bug (2026-09-04).
+  const MAX_MESSAGE_TEXT_BYTES = envInt("MAX_MESSAGE_TEXT_BYTES", 256 * 1024);
+  const MAX_TOTAL_MESSAGE_TEXT_BYTES = envInt("MAX_TOTAL_MESSAGE_TEXT_BYTES", 1024 * 1024);
+  const MAX_IMAGE_BYTES = envInt("MAX_IMAGE_BYTES", 20 * 1024 * 1024);
   const MAX_TOOLS = 64;
   const MAX_TOOL_BYTES = 128 * 1024;
   const MAX_TOTAL_TOOL_BYTES = 512 * 1024;
@@ -651,15 +661,39 @@ export function validateChatPayload(body, maxMessages = Infinity) {
     return { message: `messages must contain at most ${MAX_MESSAGES} entries`, statusCode: 413 };
   }
 
+  // Measure one message's content: text bytes (strings + text parts) and
+  // image bytes (decoded size of data: URLs in image_url parts).
+  const measure = (content) => {
+    if (typeof content === "string") return { textBytes: Buffer.byteLength(content), imageBytes: 0 };
+    let textBytes = 0, imageBytes = 0;
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (typeof part === "string") { textBytes += Buffer.byteLength(part); continue; }
+        if (part?.type === "text") { textBytes += Buffer.byteLength(typeof part.text === "string" ? part.text : JSON.stringify(part.text ?? "")); continue; }
+        if (part?.type === "image_url") {
+          const url = part?.image_url?.url;
+          if (typeof url === "string" && url.startsWith("data:")) {
+            const comma = url.indexOf(",");
+            const b64Chars = comma >= 0 ? url.length - comma - 1 : 0;
+            imageBytes += Math.floor((b64Chars * 3) / 4); // base64 → bytes
+          }
+          // remote http(s) image references cost nothing locally
+        }
+      }
+    }
+    return { textBytes, imageBytes };
+  };
+
   let totalMessageBytes = 0;
   for (const message of body.messages) {
-    const content = message?.content;
-    const text = typeof content === "string" ? content : JSON.stringify(content ?? "");
-    const bytes = Buffer.byteLength(text);
-    if (bytes > MAX_MESSAGE_TEXT_BYTES) {
+    const { textBytes, imageBytes } = measure(message?.content);
+    if (imageBytes > MAX_IMAGE_BYTES) {
+      return { message: `an image attachment is too large (max ${Math.floor(MAX_IMAGE_BYTES / 1024 / 1024)}MB per image)`, statusCode: 413 };
+    }
+    if (textBytes > MAX_MESSAGE_TEXT_BYTES) {
       return { message: "an individual message is too large", statusCode: 413 };
     }
-    totalMessageBytes += bytes;
+    totalMessageBytes += textBytes;
     if (totalMessageBytes > MAX_TOTAL_MESSAGE_TEXT_BYTES) {
       return { message: "combined message content is too large", statusCode: 413 };
     }
@@ -1185,11 +1219,24 @@ function injectSystemBanner(messages) {
     return list;
   }
   const sys = list[idx];
-  const text = typeof sys.content === "string"
-    ? sys.content
-    : Array.isArray(sys.content)
-      ? sys.content.map((p) => (typeof p === "string" ? p : p?.text || "")).join("\n")
-      : String(sys.content ?? "");
+  if (typeof sys.content === "string") {
+    if (!sys.content.includes(AUTOCLAW_SYSTEM_BANNER)) {
+      list[idx] = { ...sys, content: AUTOCLAW_SYSTEM_BANNER + "\n\n" + sys.content };
+    }
+    return list;
+  }
+  if (Array.isArray(sys.content)) {
+    // Multimodal system message — prepend the banner as a text part instead of
+    // flattening, so image parts survive.
+    const hasBanner = sys.content.some((p) =>
+      typeof p === "string" ? p.includes(AUTOCLAW_SYSTEM_BANNER)
+        : p?.type === "text" && typeof p?.text === "string" && p.text.includes(AUTOCLAW_SYSTEM_BANNER));
+    if (!hasBanner) {
+      list[idx] = { ...sys, content: [{ type: "text", text: AUTOCLAW_SYSTEM_BANNER }, ...sys.content] };
+    }
+    return list;
+  }
+  const text = String(sys.content ?? "");
   if (!text.includes(AUTOCLAW_SYSTEM_BANNER)) {
     list[idx] = { ...sys, content: AUTOCLAW_SYSTEM_BANNER + "\n\n" + text };
   }
@@ -1221,8 +1268,10 @@ function buildSanitizedBody(openAIBody, upstreamModelId) {
 export function stripProviderPrefix(modelId) { return String(modelId || "").replace(/^[a-z]+_/, ""); }
 
 // Trae and other clients send content as text-object arrays that Zhipu rejects
-// (400/500) — flatten and normalize them before forwarding.
-function normalizeClientMessages(body) {
+// (400/500) — flatten those to plain strings. Arrays carrying anything
+// non-text (image_url parts — AutoClaw's cloud accepts native vision parts,
+// probe-verified 2026-09-04) are preserved untouched so images reach the model.
+export function normalizeClientMessages(body) {
   return (body.messages || []).map(msg => {
     const newMsg = { ...msg };
 
@@ -1231,8 +1280,10 @@ function normalizeClientMessages(body) {
       newMsg.role = "system";
     }
 
-    // Flatten content array if it's all text blocks
+    // Flatten content array only when it's all text blocks
     if (Array.isArray(newMsg.content)) {
+      const hasNonText = newMsg.content.some((c) => typeof c !== "string" && c?.type !== "text");
+      if (hasNonText) return newMsg; // multimodal content — keep the part shapes
       const textParts = [];
       for (const c of newMsg.content) {
         if (typeof c === "string") textParts.push(c);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glmproxy",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "Local OpenAI- & Anthropic-compatible proxy for AutoClaw's Zhipu GLM-5.3 / GLM-5 / DeepSeek models",
   "main": "openai.js",
   "type": "module",