superoc 0.1.24 → 0.1.26

package/dist/index.js

@@ -3,6 +3,7 @@ import { describeError, is429Error, isStatusMessageRateLimited, shouldRetryForEr
 import { detectProviderForRequest, getProviderHeaders } from "./provider.js";
 import { authorizeAntigravity, exchangeAntigravity, getOrRefreshAntigravityAccessToken, getAntigravityHeaders, fetchLiveAntigravityModels, } from "./antigravity.js";
 import { BASE_ANTIGRAVITY_MODELS, syncOpencodeAuth } from "./opencode-sync.js";
+import { startAntigravityProxy, PROXY_BASE_URL, PROXY_PORT } from "./proxy.js";
 const PROVIDERS = ["nvidia", "google", "antigravity"];
 const NIM_BASE_URL = "https://integrate.api.nvidia.com";
 const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com";
@@ -74,6 +75,207 @@ function findChainIndex(chain, model) {
         return -1;
     return chain.findIndex((entry) => entry.id === model.modelID);
 }
+export function createSseUnwrapTransform() {
+    const decoder = new TextDecoder();
+    const encoder = new TextEncoder();
+    let buffer = "";
+    return new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.startsWith("data:")) {
+                    const jsonStr = line.slice(5).trim();
+                    if (!jsonStr) {
+                        controller.enqueue(encoder.encode(line + "\n"));
+                        continue;
+                    }
+                    try {
+                        const parsed = JSON.parse(jsonStr);
+                        if (parsed.response !== undefined) {
+                            controller.enqueue(encoder.encode(`data: ${JSON.stringify(parsed.response)}\n`));
+                            continue;
+                        }
+                    }
+                    catch { }
+                }
+                controller.enqueue(encoder.encode(line + "\n"));
+            }
+        },
+        flush(controller) {
+            if (buffer.length > 0) {
+                if (buffer.startsWith("data:")) {
+                    const jsonStr = buffer.slice(5).trim();
+                    try {
+                        const parsed = JSON.parse(jsonStr);
+                        if (parsed.response !== undefined) {
+                            controller.enqueue(encoder.encode(`data: ${JSON.stringify(parsed.response)}\n`));
+                            return;
+                        }
+                    }
+                    catch { }
+                }
+                controller.enqueue(encoder.encode(buffer));
+            }
+        },
+    });
+}
+export function createAntigravityFetch(store, config, reloadFromDisk, safeSaveStore) {
+    return async (input, init, fallbackFetch = fetch) => {
+        const urlString = typeof input === "string"
+            ? input
+            : input instanceof URL
+                ? input.toString()
+                : input.url;
+        if (urlString.includes("generativelanguage.googleapis.com") || urlString.includes("antigravity")) {
+            const match = urlString.match(/\/models\/([^:]+):(\w+)/);
+            const rawModel = match ? match[1] : "";
+            const action = match ? match[2] : "streamGenerateContent";
+            const isStreaming = action === "streamGenerateContent" || urlString.includes("alt=sse");
+            const isAntigravityModel = rawModel.startsWith("antigravity-") ||
+                rawModel in BASE_ANTIGRAVITY_MODELS ||
+                /claude|gpt-oss|gemini-3|gemini-pro-agent/i.test(rawModel);
+            reloadFromDisk();
+            const activeAntigravityKeys = getActiveKeys(store, "antigravity");
+            if (isAntigravityModel || activeAntigravityKeys.length > 0) {
+                if (init?.signal?.aborted) {
+                    throw new DOMException("The operation was aborted.", "AbortError");
+                }
+                let attempts = 0;
+                let lastResponse = null;
+                const maxAttempts = Math.max(1, activeAntigravityKeys.length);
+                while (attempts < maxAttempts) {
+                    if (init?.signal?.aborted) {
+                        throw new DOMException("The operation was aborted.", "AbortError");
+                    }
+                    attempts++;
+                    const next = getNextKey(store, config, rawModel, "antigravity");
+                    if (!next)
+                        break;
+                    const authRes = await getOrRefreshAntigravityAccessToken(next.key.key);
+                    if (!authRes) {
+                        continue;
+                    }
+                    if (init?.signal?.aborted) {
+                        throw new DOMException("The operation was aborted.", "AbortError");
+                    }
+                    const effectiveModel = rawModel.replace(/^antigravity-/, "");
+                    const candidateModels = [effectiveModel];
+                    if (!effectiveModel.endsWith("-tiered") &&
+                        (effectiveModel.includes("flash") || effectiveModel.includes("pro"))) {
+                        candidateModels.push(`${effectiveModel}-tiered`);
+                    }
+                    else if (effectiveModel.endsWith("-tiered")) {
+                        candidateModels.push(effectiveModel.replace(/-tiered$/, ""));
+                    }
+                    let bodyStr = init?.body;
+                    let parsedBody = typeof bodyStr === "string" ? JSON.parse(bodyStr) : bodyStr;
+                    const headers = new Headers(init?.headers ?? {});
+                    headers.set("Authorization", `Bearer ${authRes.accessToken}`);
+                    headers.set("User-Agent", `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Antigravity/1.18.3 Chrome/138.0.7204.235 Electron/37.3.1 Safari/537.36`);
+                    headers.set("X-Goog-Api-Client", "google-cloud-sdk vscode_cloudshelleditor/0.1");
+                    headers.set("Client-Metadata", `{"ideType":"ANTIGRAVITY","platform":"WINDOWS","pluginType":"GEMINI"}`);
+                    headers.delete("x-goog-api-key");
+                    headers.delete("x-api-key");
+                    headers.delete("x-goog-user-project");
+                    headers.delete("host");
+                    headers.delete("content-length");
+                    headers.delete("connection");
+                    headers.delete("transfer-encoding");
+                    const endpoints = [
+                        "https://daily-cloudcode-pa.sandbox.googleapis.com",
+                        "https://cloudcode-pa.googleapis.com",
+                    ];
+                    let gotRes = null;
+                    endpointLoop: for (const ep of endpoints) {
+                        if (init?.signal?.aborted) {
+                            throw new DOMException("The operation was aborted.", "AbortError");
+                        }
+                        for (const candidate of candidateModels) {
+                            if (init?.signal?.aborted) {
+                                throw new DOMException("The operation was aborted.", "AbortError");
+                            }
+                            const transformedUrl = `${ep}/v1internal:${action}${isStreaming ? "?alt=sse" : ""}`;
+                            const wrappedBody = JSON.stringify({
+                                project: authRes.projectId || "rising-fact-p41fc",
+                                model: candidate,
+                                request: parsedBody,
+                                requestType: "agent",
+                                userAgent: "antigravity",
+                            });
+                            try {
+                                const r = await fetch(transformedUrl, {
+                                    ...init,
+                                    headers,
+                                    body: wrappedBody,
+                                });
+                                if (r.ok) {
+                                    gotRes = r;
+                                    break endpointLoop;
+                                }
+                                if (r.status === 429) {
+                                    gotRes = r;
+                                }
+                            }
+                            catch (netErr) {
+                                if (netErr?.name === "AbortError" || init?.signal?.aborted) {
+                                    throw netErr;
+                                }
+                                if (process.env.SUPEROC_DEBUG === "true") {
+                                    console.warn(`[superoc] Endpoint ${ep} socket/network error:`, netErr);
+                                }
+                            }
+                        }
+                    }
+                    if (gotRes) {
+                        lastResponse = gotRes;
+                    }
+                    if (gotRes && gotRes.ok) {
+                        if (isStreaming && gotRes.body) {
+                            const transformedStream = gotRes.body.pipeThrough(createSseUnwrapTransform());
+                            return new Response(transformedStream, {
+                                status: gotRes.status,
+                                statusText: gotRes.statusText,
+                                headers: gotRes.headers,
+                            });
+                        }
+                        return gotRes;
+                    }
+                    if (gotRes && gotRes.status === 429) {
+                        recordRateLimit(store, next.key.id);
+                        recordModelRateLimit(store, next.key.id, rawModel);
+                        safeSaveStore();
+                        continue;
+                    }
+                    if (gotRes)
+                        return gotRes;
+                }
+                if (isAntigravityModel) {
+                    if (lastResponse)
+                        return lastResponse;
+                    return new Response(JSON.stringify({
+                        error: {
+                            code: 429,
+                            message: "All Antigravity accounts are currently rate limited or exhausted.",
+                            status: "RESOURCE_EXHAUSTED",
+                        },
+                    }), { status: 429, headers: { "Content-Type": "application/json" } });
+                }
+            }
+        }
+        return (fallbackFetch || fetch)(input, init);
+    };
+}
+export function installGlobalFetchInterceptor(fetchHandler) {
+    if (!globalThis.__superoc_fetch_installed) {
+        globalThis.__superoc_fetch_installed = true;
+        const origFetch = globalThis.fetch;
+        globalThis.fetch = async function (input, init) {
+            return fetchHandler(input, init, origFetch);
+        };
+    }
+}
 export const SuperocPlugin = async (input, options) => {
     const client = input.client;
     const config = {
@@ -428,52 +630,6 @@ export const SuperocPlugin = async (input, options) => {
         const reason = `Rate limited (429) — ${state.rateLimitCount}/${store.maxRateLimitFailures} consecutive`;
         await triggerRetry(sessionID, state, reason);
     };
-    function createSseUnwrapTransform() {
-        const decoder = new TextDecoder();
-        const encoder = new TextEncoder();
-        let buffer = "";
-        return new TransformStream({
-            transform(chunk, controller) {
-                buffer += decoder.decode(chunk, { stream: true });
-                const lines = buffer.split("\n");
-                buffer = lines.pop() || "";
-                for (const line of lines) {
-                    if (line.startsWith("data:")) {
-                        const jsonStr = line.slice(5).trim();
-                        if (!jsonStr) {
-                            controller.enqueue(encoder.encode(line + "\n"));
-                            continue;
-                        }
-                        try {
-                            const parsed = JSON.parse(jsonStr);
-                            if (parsed.response !== undefined) {
-                                controller.enqueue(encoder.encode(`data: ${JSON.stringify(parsed.response)}\n`));
-                                continue;
-                            }
-                        }
-                        catch { }
-                    }
-                    controller.enqueue(encoder.encode(line + "\n"));
-                }
-            },
-            flush(controller) {
-                if (buffer.length > 0) {
-                    if (buffer.startsWith("data:")) {
-                        const jsonStr = buffer.slice(5).trim();
-                        try {
-                            const parsed = JSON.parse(jsonStr);
-                            if (parsed.response !== undefined) {
-                                controller.enqueue(encoder.encode(`data: ${JSON.stringify(parsed.response)}\n`));
-                                return;
-                            }
-                        }
-                        catch { }
-                    }
-                    controller.enqueue(encoder.encode(buffer));
-                }
-            },
-        });
-    }
     if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
         process.env.GOOGLE_GENERATIVE_AI_API_KEY = "antigravity-oauth";
     }
@@ -481,153 +637,9 @@ export const SuperocPlugin = async (input, options) => {
         process.env.GEMINI_API_KEY = "antigravity-oauth";
     }
     syncOpencodeAuth();
-    const antigravityFetch = async (input, init, fallbackFetch = fetch) => {
-        const urlString = typeof input === "string"
-            ? input
-            : input instanceof URL
-                ? input.toString()
-                : input.url;
-        if (urlString.includes("generativelanguage.googleapis.com") || urlString.includes("antigravity")) {
-            const match = urlString.match(/\/models\/([^:]+):(\w+)/);
-            const rawModel = match ? match[1] : "";
-            const action = match ? match[2] : "streamGenerateContent";
-            const isStreaming = action === "streamGenerateContent" || urlString.includes("alt=sse");
-            const isAntigravityModel = rawModel.startsWith("antigravity-") ||
-                rawModel in BASE_ANTIGRAVITY_MODELS ||
-                /claude|gpt-oss|gemini-3|gemini-pro-agent/i.test(rawModel);
-            reloadFromDisk();
-            const activeAntigravityKeys = getActiveKeys(store, "antigravity");
-            if (isAntigravityModel || activeAntigravityKeys.length > 0) {
-                if (init?.signal?.aborted) {
-                    throw new DOMException("The operation was aborted.", "AbortError");
-                }
-                let attempts = 0;
-                let lastResponse = null;
-                const maxAttempts = Math.max(1, activeAntigravityKeys.length);
-                while (attempts < maxAttempts) {
-                    if (init?.signal?.aborted) {
-                        throw new DOMException("The operation was aborted.", "AbortError");
-                    }
-                    attempts++;
-                    const next = getNextKey(store, config, rawModel, "antigravity");
-                    if (!next)
-                        break;
-                    const authRes = await getOrRefreshAntigravityAccessToken(next.key.key);
-                    if (!authRes) {
-                        continue;
-                    }
-                    if (init?.signal?.aborted) {
-                        throw new DOMException("The operation was aborted.", "AbortError");
-                    }
-                    const effectiveModel = rawModel.replace(/^antigravity-/, "");
-                    const candidateModels = [effectiveModel];
-                    if (!effectiveModel.endsWith("-tiered") &&
-                        (effectiveModel.includes("flash") || effectiveModel.includes("pro"))) {
-                        candidateModels.push(`${effectiveModel}-tiered`);
-                    }
-                    else if (effectiveModel.endsWith("-tiered")) {
-                        candidateModels.push(effectiveModel.replace(/-tiered$/, ""));
-                    }
-                    let bodyStr = init?.body;
-                    let parsedBody = typeof bodyStr === "string" ? JSON.parse(bodyStr) : bodyStr;
-                    const headers = new Headers(init?.headers ?? {});
-                    headers.set("Authorization", `Bearer ${authRes.accessToken}`);
-                    headers.set("User-Agent", `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Antigravity/1.18.3 Chrome/138.0.7204.235 Electron/37.3.1 Safari/537.36`);
-                    headers.set("X-Goog-Api-Client", "google-cloud-sdk vscode_cloudshelleditor/0.1");
-                    headers.set("Client-Metadata", `{"ideType":"ANTIGRAVITY","platform":"WINDOWS","pluginType":"GEMINI"}`);
-                    headers.delete("x-goog-api-key");
-                    headers.delete("x-api-key");
-                    headers.delete("x-goog-user-project");
-                    const endpoints = [
-                        "https://daily-cloudcode-pa.sandbox.googleapis.com",
-                        "https://cloudcode-pa.googleapis.com",
-                    ];
-                    let gotRes = null;
-                    endpointLoop: for (const ep of endpoints) {
-                        if (init?.signal?.aborted) {
-                            throw new DOMException("The operation was aborted.", "AbortError");
-                        }
-                        for (const candidate of candidateModels) {
-                            if (init?.signal?.aborted) {
-                                throw new DOMException("The operation was aborted.", "AbortError");
-                            }
-                            const transformedUrl = `${ep}/v1internal:${action}${isStreaming ? "?alt=sse" : ""}`;
-                            const wrappedBody = JSON.stringify({
-                                project: authRes.projectId || "rising-fact-p41fc",
-                                model: candidate,
-                                request: parsedBody,
-                                requestType: "agent",
-                                userAgent: "antigravity",
-                            });
-                            try {
-                                const r = await fetch(transformedUrl, {
-                                    ...init,
-                                    headers,
-                                    body: wrappedBody,
-                                });
-                                if (r.ok) {
-                                    gotRes = r;
-                                    break endpointLoop;
-                                }
-                                if (r.status === 429) {
-                                    gotRes = r;
-                                }
-                            }
-                            catch (netErr) {
-                                if (netErr?.name === "AbortError" || init?.signal?.aborted) {
-                                    throw netErr;
-                                }
-                                if (process.env.SUPEROC_DEBUG === "true") {
-                                    console.warn(`[superoc] Endpoint ${ep} socket/network error:`, netErr);
-                                }
-                            }
-                        }
-                    }
-                    if (gotRes) {
-                        lastResponse = gotRes;
-                    }
-                    if (gotRes && gotRes.ok) {
-                        if (isStreaming && gotRes.body) {
-                            const transformedStream = gotRes.body.pipeThrough(createSseUnwrapTransform());
-                            return new Response(transformedStream, {
-                                status: gotRes.status,
-                                statusText: gotRes.statusText,
-                                headers: gotRes.headers,
-                            });
-                        }
-                        return gotRes;
-                    }
-                    if (gotRes && gotRes.status === 429) {
-                        recordRateLimit(store, next.key.id);
-                        recordModelRateLimit(store, next.key.id, rawModel);
-                        safeSaveStore();
-                        continue;
-                    }
-                    if (gotRes)
-                        return gotRes;
-                }
-                if (isAntigravityModel) {
-                    if (lastResponse)
-                        return lastResponse;
-                    return new Response(JSON.stringify({
-                        error: {
-                            code: 429,
-                            message: "All Antigravity accounts are currently rate limited or exhausted.",
-                            status: "RESOURCE_EXHAUSTED",
-                        },
-                    }), { status: 429, headers: { "Content-Type": "application/json" } });
-                }
-            }
-        }
-        return (fallbackFetch || fetch)(input, init);
-    };
-    if (!globalThis.__superoc_fetch_installed) {
-        globalThis.__superoc_fetch_installed = true;
-        const origFetch = globalThis.fetch;
-        globalThis.fetch = async function (input, init) {
-            return antigravityFetch(input, init, origFetch);
-        };
-    }
+    const antigravityFetch = createAntigravityFetch(store, config, reloadFromDisk, safeSaveStore);
+    installGlobalFetchInterceptor(antigravityFetch);
+    startAntigravityProxy(antigravityFetch);
     const hooks = {
         config: async (cfg) => {
             if (!process.env.OPENCODE_ENABLE_EXA) {
@@ -911,6 +923,281 @@ export const SuperocPlugin = async (input, options) => {
     };
     return hooks;
 };
+export async function setupV2(context) {
+    const options = context.options ?? {};
+    const config = {
+        storePath: options.storePath,
+        rotationStrategy: isValidStrategy(options.rotationStrategy)
+            ? options.rotationStrategy
+            : "round-robin",
+    };
+    const store = loadStore(config) ?? getDefaultStore();
+    if (!store.fallbackChains)
+        store.fallbackChains = { nvidia: [], google: [], antigravity: [] };
+    const sessions = new Map();
+    const reloadFromDisk = () => {
+        let fresh = null;
+        try {
+            fresh = loadStore(config);
+        }
+        catch (err) {
+            console.debug("[superoc] Failed to reload store from disk:", err);
+            return;
+        }
+        if (fresh === null)
+            return;
+        try {
+            store.keys = fresh.keys;
+            store.currentIndex = fresh.currentIndex;
+            store.rotationStrategy = fresh.rotationStrategy;
+            store.updatedAt = fresh.updatedAt;
+            store.lastUsedKeyId = fresh.lastUsedKeyId;
+            store.fallbackChains = {
+                nvidia: Array.isArray(fresh.fallbackChains?.nvidia) ? fresh.fallbackChains.nvidia : [],
+                google: Array.isArray(fresh.fallbackChains?.google) ? fresh.fallbackChains.google : [],
+                antigravity: Array.isArray(fresh.fallbackChains?.antigravity) ? fresh.fallbackChains.antigravity : [],
+            };
+            store.maxRateLimitFailures =
+                typeof fresh.maxRateLimitFailures === "number" &&
+                    Number.isFinite(fresh.maxRateLimitFailures) &&
+                    fresh.maxRateLimitFailures >= 1
+                    ? fresh.maxRateLimitFailures
+                    : getDefaultStore().maxRateLimitFailures;
+        }
+        catch (err) {
+            console.debug("[superoc] Failed to apply reloaded store:", err);
+        }
+    };
+    const safeSaveStore = () => {
+        try {
+            saveStore(store, config);
+        }
+        catch (err) {
+            console.error("[superoc] Failed to save store:", err);
+        }
+    };
+    for (const provider of PROVIDERS) {
+        const activeKeys = getActiveKeys(store, provider);
+        if (activeKeys.length === 0) {
+            const envKey = process.env[getEnvKeyName(provider)];
+            if (envKey) {
+                const existing = store.keys.find((k) => k.name === "env-default" && k.provider === provider);
+                if (!existing) {
+                    addKey(store, "env-default", envKey, provider);
+                    safeSaveStore();
+                }
+            }
+        }
+    }
+    const getState = (sessionID) => {
+        const existing = sessions.get(sessionID);
+        if (existing)
+            return existing;
+        const next = {
+            attemptIndex: 0,
+            inRetry: false,
+            aborting: false,
+            pendingRetryIndex: undefined,
+            lastUserMessageID: undefined,
+            activeChainKey: undefined,
+            activeChainModelId: undefined,
+            rateLimitCount: 0,
+            currentModelId: undefined,
+            lastFailedModelId: undefined,
+            lastErrorHandledAt: 0,
+            createdAt: Date.now(),
+            sessionProviderId: undefined,
+            lastUsedKeyId: undefined,
+        };
+        sessions.set(sessionID, next);
+        return next;
+    };
+    // Seed environment variables
+    if (!process.env.OPENCODE_ENABLE_EXA) {
+        process.env.OPENCODE_ENABLE_EXA = "1";
+    }
+    if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+        process.env.GOOGLE_GENERATIVE_AI_API_KEY = "antigravity-oauth";
+    }
+    if (!process.env.GEMINI_API_KEY) {
+        process.env.GEMINI_API_KEY = "antigravity-oauth";
+    }
+    syncOpencodeAuth();
+    // Install global fetch interceptor & local proxy server
+    const antigravityFetch = createAntigravityFetch(store, config, reloadFromDisk, safeSaveStore);
+    installGlobalFetchInterceptor(antigravityFetch);
+    startAntigravityProxy(antigravityFetch);
+    // Shell hook in V2
+    if (context.shell?.hook) {
+        await context.shell.hook("create.before", async (input) => {
+            if (input?.env) {
+                input.env["OPENCODE_ENABLE_EXA"] = "1";
+                reloadFromDisk();
+                for (const provider of PROVIDERS) {
+                    const envKeyName = getEnvKeyName(provider);
+                    if (input.env[envKeyName] !== undefined || getActiveKeys(store, provider).length > 0) {
+                        const next = getNextKey(store, config, undefined, provider);
+                        if (next) {
+                            input.env[envKeyName] = next.key.key;
+                            safeSaveStore();
+                        }
+                    }
+                }
+            }
+        });
+    }
+    // Session hooks in V2: http.request redirect and model.request auth injection
+    if (context.session?.hook) {
+        await context.session.hook("http.request", async (input) => {
+            if (input.request?.url && input.request.url.includes("generativelanguage.googleapis.com")) {
+                const newUrl = input.request.url.replace("https://generativelanguage.googleapis.com", `http://127.0.0.1:${PROXY_PORT}`);
+                input.request = new Request(newUrl, input.request);
+            }
+        });
+        await context.session.hook("model.request", async (input) => {
+            const provider = detectProviderForRequest({
+                provider: { info: { id: input.model?.providerID } },
+                model: { providerID: input.model?.providerID, api: input.model?.modelID },
+            });
+            if (!provider)
+                return;
+            reloadFromDisk();
+            const prevKeyId = store.lastUsedKeyId;
+            const modelId = input.model?.modelID;
+            const next = getNextKey(store, config, modelId, provider);
+            if (next) {
+                if (provider === "antigravity") {
+                    const authRes = await getOrRefreshAntigravityAccessToken(next.key.key);
+                    if (authRes) {
+                        const headers = getAntigravityHeaders(authRes.accessToken, authRes.projectId);
+                        input.headers = Object.assign(input.headers || {}, headers);
+                    }
+                }
+                else {
+                    const headers = getProviderHeaders(provider, next.key.key);
+                    input.headers = Object.assign(input.headers || {}, headers);
+                }
+                if (prevKeyId && prevKeyId !== next.key.id) {
+                    resetRateLimit(store, prevKeyId);
+                }
+                safeSaveStore();
+            }
+            if (input.sessionID) {
+                const state = getState(input.sessionID);
+                state.currentModelId = modelId;
+                state.sessionProviderId = provider;
+                if (next)
+                    state.lastUsedKeyId = next.key.id;
+            }
+        });
+        // Session http.response hook in V2: monitor 429 rate limits
+        await context.session.hook("http.response", async (input) => {
+            if (input.response?.status === 429) {
+                const state = input.sessionID ? sessions.get(input.sessionID) : undefined;
+                const errorKeyId = state?.lastUsedKeyId ?? store.lastUsedKeyId;
+                reloadFromDisk();
+                if (errorKeyId) {
+                    recordRateLimit(store, errorKeyId);
+                    const modelForBlacklist = state?.currentModelId;
+                    if (modelForBlacklist) {
+                        recordModelRateLimit(store, errorKeyId, modelForBlacklist);
+                    }
+                    if (state)
+                        state.lastFailedModelId = modelForBlacklist;
+                }
+                safeSaveStore();
+            }
+        });
+        // Session retry hook in V2: fallback model switching
+        await context.session.hook("retry", async (input) => {
+            const sessionID = input.sessionID;
+            if (!sessionID)
+                return;
+            const state = getState(sessionID);
+            const provider = state.sessionProviderId ?? "nvidia";
+            const chain = store.fallbackChains[provider] || [];
+            if (chain.length < 2)
+                return;
+            let nextIndex = (state.attemptIndex + 1) % chain.length;
+            const target = chain[nextIndex];
+            if (target && context.session?.switchModel) {
+                state.attemptIndex = nextIndex;
+                state.currentModelId = target.id;
+                try {
+                    await context.session.switchModel({
+                        sessionID,
+                        model: { providerID: state.sessionProviderId ?? provider, modelID: target.id },
+                    });
+                }
+                catch (err) {
+                    console.debug("[superoc] switchModel failed:", err);
+                }
+            }
+        });
+    }
+    // Provider & Model transform in V2
+    if (context.provider?.transform) {
+        await context.provider.transform((editor) => {
+            const existing = editor.get?.("antigravity");
+            if (!existing && editor.add) {
+                editor.add({
+                    info: {
+                        id: "antigravity",
+                        name: "Antigravity",
+                        package: "aisdk:@ai-sdk/google",
+                        settings: {
+                            baseURL: PROXY_BASE_URL,
+                        },
+                    },
+                    models: [],
+                });
+            }
+        });
+    }
+    if (context.model?.transform) {
+        await context.model.transform((editor) => {
+            for (const [id, def] of Object.entries(BASE_ANTIGRAVITY_MODELS)) {
+                if (!editor.get?.("antigravity", id) && editor.update) {
+                    editor.update("antigravity", id, (draft) => {
+                        Object.assign(draft, {
+                            name: def.name,
+                            limit: def.limit,
+                            capabilities: {
+                                tools: true,
+                                input: ["text", "image", "pdf"],
+                                output: ["text"],
+                            },
+                        });
+                    });
+                }
+            }
+        });
+    }
+    // Query live Antigravity models in background
+    reloadFromDisk();
+    const activeKeys = getActiveKeys(store, "antigravity");
+    if (activeKeys.length > 0) {
+        getOrRefreshAntigravityAccessToken(activeKeys[0].key)
+            .then(async (auth) => {
+            if (auth) {
+                try {
+                    await fetchLiveAntigravityModels(auth.accessToken, auth.projectId);
+                }
+                catch { }
+            }
+        })
+            .catch(() => { });
+    }
+    return () => {
+        sessions.clear();
+    };
+}
+export const SuperocPluginV2 = {
+    id: "superoc",
+    setup: setupV2,
+    server: SuperocPlugin,
+};
 export const NimSuperPlugin = SuperocPlugin;
-export default SuperocPlugin;
+export { SuperocPlugin as server };
+export default SuperocPluginV2;
 //# sourceMappingURL=index.js.map