clauderipple 0.6.0 → 0.8.0

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";
@@ -177,6 +179,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;
@@ -253,6 +256,20 @@ export class Proxy {
             return this.chatgpt(first[0], first[1]);
         return this.chatgpt("codex-login", { type: "chatgpt", auth: "borrow-codex" });
     }
+    /**
+     * One image for `/api/image`, on the first chatgpt provider and the first model it declares. The
+     * model only runs the tool call — the image comes from the backend's own image model — so which
+     * one it is barely matters.
+     */
+    generateImage(req, signal) {
+        const first = Object.entries(this.deps.config().providers).find(([, p]) => p.type === "chatgpt");
+        if (!first || first[1].type !== "chatgpt")
+            return Promise.reject(new Error("image generation needs a ChatGPT provider; add one in the dashboard"));
+        const model = first[1].models?.[0]?.id;
+        if (!model)
+            return Promise.reject(new Error(`provider ${first[0]} declares no models`));
+        return this.chatgpt(first[0], first[1]).generateImage(model, req, signal);
+    }
     /** Dashboard action: put one resting ChatGPT account back into rotation now. */
     chatgptClearCooldown(ownerId) {
         for (const [name, p] of Object.entries(this.deps.config().providers)) {
@@ -278,6 +295,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({
@@ -511,6 +574,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,
@@ -733,6 +799,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);
@@ -1134,7 +1232,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.6.0";
+export const VERSION = "0.8.0";