clauderipple 0.7.0 → 0.8.1

package/dist/router/src/providers/openai/translate.js

@@ -3,7 +3,7 @@
 // stable prompt prefix can retain their native prompt-cache behavior.
 import crypto from "node:crypto";
 import { clampEffort } from "../../compat.js";
-import { conversationKey, estimateTokens, normalizeSchema, serverToolNames, systemText, toolNameForResponses } from "../chatgpt/translate.js";
+import { conversationKey, estimateTokens, normalizeSchema, serverToolNames, systemWithDroppedToolNote, toolNameForResponses } from "../chatgpt/translate.js";
 import { identityPrefix, instructionsSuffix } from "../../identity.js";
 function textOf(content) {
     if (typeof content === "string")
@@ -87,7 +87,7 @@ function mappedEffort(opts) {
 /** Convert every Anthropic message into OpenAI Chat Completion messages without inventing unstable text. */
 export function toChatMessages(req, opts) {
     const messages = [];
-    const sys = systemText(req.system);
+    const sys = systemWithDroppedToolNote(req);
     const content = opts ? systemWithIdentity(sys, opts) : sys;
     if (content)
         messages.push({ role: "system", content });
@@ -248,7 +248,7 @@ export function toOpenAiRequest(req, opts) {
         input: toResponsesInput(req),
         stream: true,
     };
-    const instructions = systemWithIdentity(systemText(req.system), opts);
+    const instructions = systemWithIdentity(systemWithDroppedToolNote(req), opts);
     if (instructions)
         out.instructions = instructions;
     if (responseTools.length) {

package/dist/router/src/proxy.js

@@ -29,9 +29,11 @@ import { classify, CredentialPool, retryAfterMs } from "./pool.js";
 import { PRESETS } from "./presets.js";
 import { ChatGptAdapter } from "./providers/chatgpt/index.js";
 import { OpenAiCompatibleAdapter } from "./providers/openai/index.js";
+import { GoogleAdapter } from "./providers/google/index.js";
 import { conversationKey } from "./providers/chatgpt/translate.js";
 import { providerFor, terminateHosts } from "./config.js";
 import { injectPickerModels, isBootstrapPath } from "./picker.js";
+import { effortLevelsForModel } from "./admin.js";
 import { ResponseUsageTap } from "./requestlog.js";
 import { credentialHeaderValues, redactErrorText, redactHeaders } from "./redact.js";
 import { ClaudeAccountAuthPool } from "./providers/anthropic-account-pool.js";
@@ -45,11 +47,15 @@ const HOP_BY_HOP = new Set(["connection", "keep-alive", "proxy-connection", "tra
 const CLIENT_AUTH = new Set(["authorization", "x-api-key"]);
 /** How much of an upstream error body is kept for the log. */
 const ERROR_HEAD_MAX = 4096;
+/** Methods safe to send twice (RFC 9110 §9.2.2), and so the only ones resent after a stale socket. */
+const IDEMPOTENT = new Set(["GET", "HEAD", "OPTIONS"]);
 /**
  * Claude Code's Remote Control registration uses HTTPS absolute-form proxy requests instead of
  * CONNECT (`POST https://api.anthropic.com/v1/environments/bridge HTTP/1.1`). Convert that legal
  * forward-proxy form to the origin form expected inside a TLS connection. Credentials and the
  * request body remain byte-for-byte client data; proxy-only headers never reach the destination.
+ * Plain `http:` takes the same form and is relayed over TCP: Claude Code 2.1.288 sends its http
+ * requests through HTTPS_PROXY too, loopback included (a mod reading the admin API got our 405).
  */
 export function absoluteProxyRequest(header) {
     const lines = header.toString("latin1").split("\r\n");
@@ -64,9 +70,10 @@ export function absoluteProxyRequest(header) {
     catch {
         return null;
     }
-    if (url.protocol !== "https:" || url.username || url.password || url.hash || !url.hostname)
+    const secure = url.protocol === "https:";
+    if ((!secure && url.protocol !== "http:") || url.username || url.password || url.hash || !url.hostname)
         return null;
-    const port = url.port ? Number(url.port) : 443;
+    const port = url.port ? Number(url.port) : secure ? 443 : 80;
     if (!Number.isInteger(port) || port < 1 || port > 65535)
         return null;
     // URL.hostname keeps brackets around IPv6 literals; net/tls expect the bare address while the
@@ -77,10 +84,10 @@ export function absoluteProxyRequest(header) {
         !/^connection\s*:/i.test(line));
     const authority = url.port ? `${url.hostname}:${url.port}` : url.hostname;
     const path = `${url.pathname || "/"}${url.search}`;
-    // One TLS connection serves one absolute-form request. Reusing it would send the next proxy-form
+    // One upstream connection serves one absolute-form request. Reusing it would send the next proxy-form
     // request target directly to the origin, so explicitly ask both peers to close after the response.
     const rewritten = [`${match[1]} ${path} ${match[3]}`, `Host: ${authority}`, "Connection: close", ...headers].join("\r\n") + "\r\n\r\n";
-    return { host, port, path, head: Buffer.from(rewritten, "latin1") };
+    return { host, port, path, head: Buffer.from(rewritten, "latin1"), tls: secure };
 }
 /**
  * The same header list with one credential swapped for another. Names carried by either credential
@@ -177,6 +184,7 @@ export class Proxy {
     providerAgents = new Map();
     chatgptAdapters = new Map();
     openaiAdapters = new Map();
+    googleAdapters = new Map();
     claudeAccounts;
     /** Each Claude subscription account's usage, for the admin status (never a token). */
     claudeUsage;
@@ -292,6 +300,52 @@ export class Proxy {
         this.openaiAdapters.set(name, { key, adapter });
         return adapter;
     }
+    google(name, cfg) {
+        const key = JSON.stringify(cfg);
+        const cur = this.googleAdapters.get(name);
+        if (cur && cur.key === key)
+            return cur.adapter;
+        const adapter = new GoogleAdapter(name, cfg, this.deps.home, this.deps.log, this.pool);
+        this.googleAdapters.set(name, { key, adapter });
+        return adapter;
+    }
+    /**
+     * Every configured google provider's Antigravity accounts: rotation state only, never a token.
+     * Empty for api-key providers and for an adapter that has not been created yet.
+     */
+    googleAccounts() {
+        const out = {};
+        for (const [name, p] of Object.entries(this.deps.config().providers)) {
+            if (p.type === "google" && p.auth === "antigravity")
+                out[name] = this.google(name, p).accountStatus();
+        }
+        return out;
+    }
+    /** The models a google provider can reach now, from Cloud Code Assist's own catalogue. */
+    googleFetchModels(name) {
+        const cfg = this.deps.config().providers[name];
+        if (!cfg || cfg.type !== "google" || cfg.auth !== "antigravity")
+            return Promise.resolve(null);
+        return this.google(name, cfg).fetchModels();
+    }
+    /** Dashboard action: put one resting Google account back into rotation now. */
+    googleClearCooldown(ownerId) {
+        for (const [name, p] of Object.entries(this.deps.config().providers)) {
+            if (p.type === "google" && p.auth === "antigravity")
+                this.google(name, p).clearCooldown(ownerId);
+        }
+    }
+    /** Ask again whether an account still needs Google's verification page; the first provider that knows answers. */
+    async googleRecheckVerification(ownerId) {
+        for (const [name, p] of Object.entries(this.deps.config().providers)) {
+            if (p.type !== "google" || p.auth !== "antigravity")
+                continue;
+            const result = await this.google(name, p).recheckVerification(ownerId);
+            if (result !== "unknown")
+                return result;
+        }
+        return "unknown";
+    }
     constructor(deps) {
         this.deps = deps;
         this.claudeAccounts = new ClaudeAccountAuthPool({
@@ -376,7 +430,7 @@ export class Proxy {
             if (method !== "CONNECT" || !target) {
                 const absolute = absoluteProxyRequest(head.subarray(0, end));
                 if (absolute) {
-                    log.info(`ABSOLUTE ${method ?? "?"} https://${absolute.host}:${absolute.port}${absolute.path}`);
+                    log.info(`ABSOLUTE ${method ?? "?"} ${absolute.tls ? "https" : "http"}://${absolute.host}:${absolute.port}${absolute.path}`);
                     this.forwardAbsolute(sock, absolute, rest);
                     return;
                 }
@@ -401,7 +455,9 @@ export class Proxy {
     /** Forward an HTTPS absolute-form request without terminating it through the routing layer. */
     forwardAbsolute(sock, request, rest) {
         const servername = net.isIP(request.host) ? undefined : request.host;
-        const up = (this.deps.tlsConnect ?? tls.connect)({ host: request.host, port: request.port, ...(servername ? { servername } : {}), ALPNProtocols: ["http/1.1"] });
+        const up = request.tls
+            ? (this.deps.tlsConnect ?? tls.connect)({ host: request.host, port: request.port, ...(servername ? { servername } : {}), ALPNProtocols: ["http/1.1"] })
+            : net.connect({ host: request.host, port: request.port });
         const kill = () => {
             sock.destroy();
             up.destroy();
@@ -413,7 +469,7 @@ export class Proxy {
             up.destroy();
         });
         sock.on("error", kill);
-        up.once("secureConnect", () => {
+        up.once(request.tls ? "secureConnect" : "connect", () => {
             up.write(request.head);
             if (rest.length)
                 up.write(rest);
@@ -525,6 +581,9 @@ export class Proxy {
             provider: "anthropic",
             stream: false,
         };
+        const session = req.headers["x-claude-code-session-id"];
+        if (typeof session === "string" && /^[\w-]{1,128}$/.test(session))
+            record.session = session;
         let observedUsage;
         let observedStopReason;
         // `failed` counts requests that did not get a proper response (vanished, upstream error,
@@ -747,6 +806,38 @@ export class Proxy {
                 }
                 return;
             }
+            if (provider.type === "google") {
+                // Google holds no server-side thread either, so a `continue` is refused as it is for the
+                // other translated providers; the CLI resends the turn with the full history.
+                const td = threadDecision(json);
+                if (td === "refuse") {
+                    const out = JSON.stringify(THREAD_UNSUPPORTED);
+                    res.writeHead(400, { "content-type": "application/json", "content-length": String(Buffer.byteLength(out)) }).end(out);
+                    finish("400", out.length, "thread continue refused → CLI resends stateless", false);
+                    return;
+                }
+                if (td === "strip")
+                    stripThreadFields(json);
+                record = { ...record, target: route.model, provider: route.provider };
+                const routeEffort = effortOf(json);
+                if (routeEffort)
+                    record.effort = routeEffort;
+                tag = `GOOGLE ${route.tag} effort=${routeEffort ?? "-"}`;
+                try {
+                    const o = await this.google(route.provider, provider).handle(req, res, path, json, route.model, routeEffort);
+                    this.recordOutcome(route.provider, o.status);
+                    finish(String(o.status), o.bytes, o.note, o.status >= 400, { ...(o.usage ? { usage: o.usage } : {}), ...(o.stopReason ? { stopReason: o.stopReason } : {}) });
+                }
+                catch (e) {
+                    this.recordOutcome(route.provider, 0);
+                    finish("-", 0, `google error ${e.code ?? ""} ${e.message}`);
+                    if (!res.headersSent)
+                        res.writeHead(502, { "content-type": "application/json" }).end(JSON.stringify({ type: "error", error: { type: "api_error", message: e.message } }));
+                    else
+                        res.destroy();
+                }
+                return;
+            }
             if (provider.type === "anthropic") {
                 if (!provider.accountPool || provider.auth !== "claude-code") {
                     finish("400", 0, "native Anthropic provider is available through OpenAI ingress only", false);
@@ -852,7 +943,7 @@ export class Proxy {
             }
         }
         else if (isApiHost) {
-            target = { protocol: "https:", host: cfg.upstream, port: 443, agent: this.upstreamAgent, extraHeaders: {} };
+            target = { protocol: "https:", host: cfg.upstream, port: this.deps.upstreamPort ?? 443, agent: this.deps.upstreamAgent ?? this.upstreamAgent, extraHeaders: {} };
             tag = `PASS ${typeof model === "string" ? model : "-"}`;
             // Passthrough stays byte-exact unless another model's thinking would get the turn refused.
             if (json && dropForeignThinking(json) > 0)
@@ -921,7 +1012,11 @@ export class Proxy {
         let upReq;
         /** Credentials already spent on this turn, so a retry cannot pick one of them again. */
         const tried = new Set(penalised ? [penalised.id] : []);
+        /** The headers of the attempt in flight, so a stale-socket resend repeats exactly that attempt. */
+        let lastAttemptHeaders = headers;
+        let staleRetries = 0;
         const send = (attemptHeaders) => {
+            lastAttemptHeaders = attemptHeaders;
             upReq = lib.request({
                 protocol: target.protocol,
                 host: target.host,
@@ -989,6 +1084,18 @@ export class Proxy {
             }
         });
         const onUpstreamError = (e) => {
+            // A kept-alive socket the upstream had already closed: the reset arrives before any response,
+            // so the request never reached it. claude.ai did this 259 times in four days of picker mode
+            // (2026-10-03..06), each one a 502 on an app request such as `current_user_access`. Send an
+            // idempotent request again on a fresh attempt instead of failing it; a POST is never resent,
+            // since a reset cannot prove the upstream did not act on it.
+            const code = e.code;
+            if (upReq.reusedSocket && (code === "ECONNRESET" || code === "EPIPE") && IDEMPOTENT.has(method) && !clientAborted && !res.headersSent && staleRetries < 2) {
+                staleRetries++;
+                log.info(`STALE ${reqHost}: kept-alive socket was closed (${code}); resending ${method} ${path.slice(0, 60)}`);
+                send(lastAttemptHeaders);
+                return;
+            }
             if (target.host === cfg.upstream)
                 this.deps.health.failure(e);
             // Nothing reached the provider, so this says nothing about the credential — but it does say
@@ -1148,7 +1255,7 @@ export class Proxy {
                     else if (status === 200 && isPickerBootstrap) {
                         try {
                             const j = JSON.parse(out.toString("utf8"));
-                            const r = injectPickerModels(j, cfg.cli.extraModels, cfg.cli.autoCompactWindow);
+                            const r = injectPickerModels(j, cfg.cli.extraModels, cfg.cli.autoCompactWindow, (model) => effortLevelsForModel(cfg, model));
                             if (r.surfaces.length > 0) {
                                 this.lastPickerInjection = { at: new Date().toISOString(), ...r };
                                 out = Buffer.from(JSON.stringify(j));

package/dist/router/src/requestlog.js

@@ -56,6 +56,8 @@ export class RequestLog {
                 continue;
             if (filter.kind && record.kind !== filter.kind)
                 continue;
+            if (filter.session && record.session !== filter.session)
+                continue;
             out.push(record);
         }
         return out;

package/dist/router/src/routing.js

@@ -50,6 +50,18 @@ export function markerOverride(body, aliases) {
 export function resolve(model, body, cfg) {
     if (typeof model !== "string")
         return null;
+    // Measured on Desktop's engine 2.1.284: the registered AUTO_MODE_MODEL env var is
+    // unused. Match the classifier's system prompt, never quoted conversation text.
+    // Its decision and wire format remain the engine's; only the inference target changes.
+    if (cfg.autoModeClassifier && isAutoModeClassifier(body)) {
+        const target = cfg.autoModeClassifier;
+        return {
+            provider: target.provider,
+            model: target.model,
+            effort: target.effort,
+            tag: `${model}->${target.model} (auto-mode classifier)`,
+        };
+    }
     let base = model;
     let effort;
     const at = model.indexOf("@");
@@ -128,6 +140,16 @@ export function resolve(model, body, cfg) {
         return null;
     return { provider: owner, model: finalModel, effort: ov?.effort ?? effort, tag: `${model}->${finalModel}${ov ? " (marker)" : ""}` };
 }
+export function isAutoModeClassifier(body) {
+    const request = body;
+    if (!request || (Array.isArray(request.tools) && request.tools.length > 0))
+        return false;
+    const system = request.system;
+    const texts = typeof system === "string" ? [system] : Array.isArray(system)
+        ? system.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text)
+        : [];
+    return texts.some((text) => text.trimStart().startsWith("You are a security monitor for autonomous AI coding agents."));
+}
 /**
  * Providers whose own `models` list carries this id. Dated and undated forms match each other, the
  * same way a slot lookup does. Ingress-only providers are included on purpose — see the call site.

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.7.0";
+export const VERSION = "0.8.1";