@oracle-agent/oracle 0.9.8 → 0.11.0

package/src/router/route-sources.mjs

@@ -21,6 +21,7 @@ import { zeroxQuote } from "../data/providers/zerox.mjs";
 import { oneinchQuote } from "../data/providers/oneinch.mjs";
 import { cowQuote } from "../data/providers/cowswap.mjs";
 import { uniV3QuoteExactIn, UNI_V3_CHAINS } from "../data/providers/uniswap-v3.mjs";
+import { uniV4QuoteExactIn, UNI_V4_CHAINS } from "../data/providers/uniswap-v4.mjs";
 import { llamaPrices } from "../data/providers/defillama.mjs";
 import { NATIVE_PRICE_KEY } from "./best-execution.mjs";
 
@@ -67,6 +68,7 @@ export function swapCandidates({
   tokenOut,
   amountIn,
   taker,
+  slippageBps,
   decimalsIn,
   decimalsOut,
   nativePriceUsd = null,
@@ -225,6 +227,39 @@ export function swapCandidates({
     });
   }
 
+  // Uniswap V4 Quoter. Cross-chain floor alongside V3. On RH the live SQUEEZE book
+  // is V4; V3 alone can return a drained shell that looks like a real quote. Kept
+  // after V3 so best-execution still compares net output when both answer.
+  if (UNI_V4_CHAINS[Number(chainId)]) {
+    c.push({
+      source: "uniswap-v4",
+      run: async () => {
+        const q = await uniV4QuoteExactIn(
+          { chainId, tokenIn, tokenOut, amountIn, recipient: taker, slippageBps },
+          opts,
+        );
+        return {
+          amountOut: q?.amountOut,
+          minOut: q?.minOut ?? q?.amountOutMinimum ?? null,
+          gasUsd: null,
+          meta: {
+            onchain: true,
+            venue: "uniswap-v4",
+            fee: q?.fee,
+            tickSpacing: q?.tickSpacing,
+            poolId: q?.poolId,
+            hooks: q?.hooks,
+            gasUnits: q?.gasEstimate,
+            quoter: q?.quoter,
+            poolManager: q?.poolManager,
+            prepareReady: q?.prepareReady === true,
+            executionReady: false,
+          },
+        };
+      },
+    });
+  }
+
   return c;
 }
 

package/src/tui/app.mjs

@@ -371,23 +371,34 @@ export function createOracleTui(options = {}) {
   });
 }
 
-export async function runOracleTui({ hermesPython, args = [], env = process.env, cwd = process.cwd(), stdout = process.stdout, stdin = process.stdin } = {}) {
+export async function runOracleTui({
+  hermesPython,
+  client,
+  tuiFactory = createOracleTui,
+  args = [],
+  env = process.env,
+  cwd = process.cwd(),
+  stdout = process.stdout,
+  stdin = process.stdin,
+} = {}) {
   const parsed = parseChatArgs(args);
   if (parsed.query) return { native: false, pass: parsed.pass };
   if (!stdin.isTTY || !stdout.isTTY) return { native: false, pass: parsed.pass };
-  // Native TUI is intentionally opt-in while the stable oracle shim remains pinned.
-  if (env.ORACLE_NATIVE_TUI !== "1") return { native: false, pass: parsed.pass };
+  if (env.ORACLE_NATIVE_TUI === "0") return { native: false, pass: parsed.pass };
   const invocation = hermesPython;
-  if (!invocation) return { native: false, pass: parsed.pass };
+  if (!client && !invocation) return { native: false, pass: parsed.pass };
   const cleanEnv = activeChainEnv({
     ...env,
     ORACLE_CHAT_SURFACE: "1",
     ORACLE_PROFILE: "oracle",
     ORACLE_NODE_BIN: process.execPath,
   });
-  const tui = createOracleTui({
-    python: invocation.command,
-    pythonArgs: invocation.prefix || [],
+  const tui = tuiFactory({
+    ...(client ? { client } : {}),
+    ...(invocation ? {
+      python: invocation.command,
+      pythonArgs: invocation.prefix || [],
+    } : {}),
     cwd,
     env: cleanEnv,
     stdin,

package/src/tui/backend.mjs

@@ -0,0 +1,145 @@
+const PROVIDERS = Object.freeze({
+  openrouter: {
+    key: "OPENROUTER_API_KEY",
+    baseUrl: "https://openrouter.ai/api/v1",
+    model: "openrouter/auto",
+  },
+  openai: {
+    key: "OPENAI_API_KEY",
+    baseUrl: "https://api.openai.com/v1",
+    model: "gpt-4.1-mini",
+  },
+  xai: {
+    key: "XAI_API_KEY",
+    baseUrl: "https://api.x.ai/v1",
+    model: "grok-4-latest",
+  },
+  deepseek: {
+    key: "DEEPSEEK_API_KEY",
+    baseUrl: "https://api.deepseek.com/v1",
+    model: "deepseek-chat",
+  },
+  gemini: {
+    key: "GEMINI_API_KEY",
+    alternateKey: "GOOGLE_API_KEY",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+    model: "gemini-2.5-flash",
+  },
+});
+
+const OAUTH_PROVIDERS = Object.freeze({
+  "anthropic-oauth": {
+    baseUrl: "https://api.anthropic.com/v1",
+    model: "claude-sonnet-4-6",
+    protocol: "anthropic-messages",
+  },
+  "openai-codex": {
+    baseUrl: "https://chatgpt.com/backend-api/codex",
+    model: "gpt-5.6-sol",
+    protocol: "responses",
+  },
+  "xai-oauth": {
+    baseUrl: "https://api.x.ai/v1",
+    model: "grok-4.5",
+    protocol: "responses",
+  },
+});
+
+function positiveInteger(value, fallback) {
+  const parsed = Number.parseInt(String(value || ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function providerFromEnv(env, stored = {}) {
+  const explicit = String(env.ORACLE_PROVIDER || stored.provider || "").trim().toLowerCase();
+  if (explicit) return explicit;
+  if (env.ORACLE_BASE_URL) return "custom";
+  for (const [name, preset] of Object.entries(PROVIDERS)) {
+    if (env[preset.key] || (preset.alternateKey && env[preset.alternateKey])) return name;
+  }
+  return null;
+}
+
+export function standaloneConfigFromEnv(
+  env = process.env,
+  stored = {},
+  oauthAvailable = () => false,
+  apiKeyResolver = () => "",
+) {
+  const provider = providerFromEnv(env, stored);
+  if (!provider) return null;
+
+  const oauthPreset = OAUTH_PROVIDERS[provider];
+  const preset = PROVIDERS[provider] || oauthPreset;
+  const apiKeyEnv = String(env.ORACLE_API_KEY_ENV || stored.apiKeyEnv || "");
+  const apiKey = String(
+    env.ORACLE_API_KEY ||
+    (apiKeyEnv && env[apiKeyEnv]) ||
+    (preset && (env[preset.key] || (preset.alternateKey && env[preset.alternateKey]))) ||
+    apiKeyResolver(provider) ||
+    "",
+  );
+  const baseUrl = String(
+    oauthPreset
+      ? oauthPreset.baseUrl
+      : provider === "custom"
+        ? (env.ORACLE_BASE_URL || stored.baseUrl || "")
+        : (preset?.baseUrl || ""),
+  ).replace(/\/+$/, "");
+  const model = String(env.ORACLE_MODEL || stored.model || preset?.model || "");
+  if (!baseUrl || !model) return null;
+  const hasOAuth = Boolean(oauthPreset && oauthAvailable(provider));
+  if (oauthPreset && !hasOAuth) return null;
+  if (!oauthPreset && provider !== "custom" && !apiKey) return null;
+
+  return {
+    kind: "standalone",
+    provider,
+    model,
+    baseUrl,
+    ...(hasOAuth ? { authType: "oauth", protocol: oauthPreset.protocol } : { apiKey }),
+    contextLength: positiveInteger(env.ORACLE_CONTEXT_LENGTH || stored.contextLength, 128000),
+    reasoningEffort: String(env.ORACLE_REASONING_EFFORT || stored.reasoningEffort || "high"),
+  };
+}
+
+function setupReason(extra = "") {
+  return [
+    "Oracle standalone chat does not require Hermes.",
+    "Set OPENROUTER_API_KEY, run `oracle auth login claude|codex|grok`, or configure a custom OpenAI-compatible endpoint.",
+    "If Hermes is installed, Oracle will reuse it automatically.",
+    extra,
+  ].filter(Boolean).join("\n");
+}
+
+export function resolveChatBackend({
+  env = process.env,
+  hermes = { ok: false },
+  storedConfig = null,
+  oauthAvailable = () => false,
+  apiKeyResolver = () => "",
+} = {}) {
+  const requested = String(env.ORACLE_CHAT_BACKEND || storedConfig?.backend || "auto").trim().toLowerCase();
+  const standalone = standaloneConfigFromEnv(env, storedConfig || {}, oauthAvailable, apiKeyResolver);
+
+  if (requested === "standalone") {
+    return standalone
+      ? { kind: "standalone", config: standalone }
+      : { kind: "unconfigured", reason: setupReason("ORACLE_CHAT_BACKEND=standalone was requested, but no standalone model is configured.") };
+  }
+
+  if (requested === "hermes") {
+    return hermes?.ok
+      ? { kind: "hermes", bin: hermes.bin }
+      : { kind: "unconfigured", reason: setupReason("ORACLE_CHAT_BACKEND=hermes was requested, but Hermes was not found.") };
+  }
+
+  if (requested !== "auto") {
+    return { kind: "unconfigured", reason: setupReason(`Unknown ORACLE_CHAT_BACKEND value: ${requested}`) };
+  }
+  if (hermes?.ok) return { kind: "hermes", bin: hermes.bin };
+  if (standalone) return { kind: "standalone", config: standalone };
+  return { kind: "unconfigured", reason: setupReason() };
+}
+
+export default { resolveChatBackend, standaloneConfigFromEnv };