@lazyingart/agintiflow 0.18.0 → 0.19.0

package/src/model-routing.js

@@ -69,6 +69,83 @@ const COMPLEX_ROUTE_HINTS = [
 
 export const ROUTING_MODES = ["smart", "fast", "complex", "manual"];
 
+export const MODEL_PROVIDER_GROUPS = {
+  deepseek: {
+    label: "DeepSeek",
+    provider: "deepseek",
+    role: "default route/main",
+    description: "Primary low-cost coding route. Flash is used for fast planning; Pro is used for complex execution.",
+  },
+  openai: {
+    label: "OpenAI",
+    provider: "openai",
+    role: "spare/frontier",
+    description: "Optional frontier spare or direct manual route, usually with explicit reasoning effort.",
+  },
+  qwen: {
+    label: "Qwen",
+    provider: "qwen",
+    role: "regional/general",
+    description: "DashScope/OpenAI-compatible Qwen route for Chinese and general work.",
+  },
+  "venice-uncensored": {
+    label: "Venice Uncensored",
+    provider: "venice",
+    role: "alternate text",
+    description: "Venice uncensored text models for optional manual routes.",
+  },
+  "venice-gpt": {
+    label: "Venice GPT",
+    provider: "venice",
+    role: "alternate GPT",
+    description: "GPT-family models routed through Venice.",
+  },
+  "venice-claude": {
+    label: "Venice Claude",
+    provider: "venice",
+    role: "alternate Claude",
+    description: "Claude-family models routed through Venice.",
+  },
+  "venice-gemma": {
+    label: "Venice Gemma",
+    provider: "venice",
+    role: "alternate Gemma",
+    description: "Gemma-family Venice models.",
+  },
+  "venice-qwen": {
+    label: "Venice Qwen",
+    provider: "venice",
+    role: "alternate Qwen",
+    description: "Qwen-family Venice models.",
+  },
+};
+
+export const AUXILIARY_MODEL_CATALOG = {
+  grsai: [
+    {
+      id: "nano-banana-2",
+      label: "Nano Banana 2",
+      type: "image",
+      description: "Default auxiliary image-generation route through GRS AI-compatible APIs.",
+    },
+    {
+      id: "gpt-image-2",
+      label: "GPT Image 2",
+      type: "image",
+      description: "High-quality image generation when available through the configured auxiliary endpoint.",
+    },
+  ],
+  "venice-image": [
+    { id: "nano-banana-2", label: "Nano Banana 2", type: "image", price: "$0.10/image" },
+    { id: "gpt-image-2", label: "GPT Image 2", type: "image", price: "$0.27/image" },
+    { id: "gpt-image-2-edit", label: "GPT Image 2 Edit", type: "inpaint", price: "$0.36/edit" },
+    { id: "wan-2-7-pro-edit", label: "Wan 2.7 Pro Edit", type: "inpaint", price: "$0.09/edit" },
+    { id: "grok-imagine-image", label: "Grok Imagine", type: "image", price: "$0.03/image" },
+    { id: "qwen-image-2-pro", label: "Qwen Image 2 Pro", type: "image", price: "$0.10/image" },
+    { id: "bria-bg-remover", label: "Background Remover", type: "image", price: "$0.03/image" },
+  ],
+};
+
 export const PROVIDER_MODEL_CATALOG = {
   deepseek: [
     {
@@ -250,20 +327,35 @@ export function getProviderDefaults(provider = "deepseek") {
   };
 }
 
-export function getModelPresets() {
+function providerDefaultModel(provider, fallback) {
+  if (provider === "deepseek" && fallback) return fallback;
+  return getProviderDefaults(provider).model || fallback;
+}
+
+export function getModelPresets(overrides = {}) {
+  const routeProvider = overrides.routeProvider || process.env.AGINTI_ROUTE_PROVIDER || "deepseek";
+  const mainProvider = overrides.mainProvider || process.env.AGINTI_MAIN_PROVIDER || "deepseek";
   return {
     fast: {
       id: "fast",
       label: "Fast base",
-      provider: "deepseek",
-      model: process.env.DEEPSEEK_FAST_MODEL || "deepseek-v4-flash",
+      provider: routeProvider,
+      model:
+        overrides.routeModel ||
+        process.env.AGINTI_ROUTE_MODEL ||
+        process.env.DEEPSEEK_FAST_MODEL ||
+        providerDefaultModel(routeProvider, "deepseek-v4-flash"),
       description: "Default fast route for normal browser, shell, and short coding tasks.",
     },
     complex: {
       id: "complex",
       label: "Complex reasoning",
-      provider: "deepseek",
-      model: process.env.DEEPSEEK_PRO_MODEL || "deepseek-v4-pro",
+      provider: mainProvider,
+      model:
+        overrides.mainModel ||
+        process.env.AGINTI_MAIN_MODEL ||
+        process.env.DEEPSEEK_PRO_MODEL ||
+        providerDefaultModel(mainProvider, "deepseek-v4-pro"),
       description: "Higher-capacity DeepSeek route for multi-step coding and design tasks.",
     },
     mock: {
@@ -367,8 +459,9 @@ export function getModelPresets() {
       id: "codexPrimary",
       label: "Codex primary wrapper",
       provider: "codex-wrapper",
-      model: process.env.CODEX_PRIMARY_MODEL || "gpt-5.5",
-      reasoning: process.env.CODEX_PRIMARY_REASONING || "medium",
+      model: overrides.wrapperModel || process.env.AGINTI_WRAPPER_MODEL || process.env.CODEX_PRIMARY_MODEL || "gpt-5.5",
+      reasoning:
+        overrides.wrapperReasoning || process.env.AGINTI_WRAPPER_REASONING || process.env.CODEX_PRIMARY_REASONING || "medium",
       description: "External Codex wrapper route for coding enhancement tasks.",
     },
     codexSpare: {
@@ -382,6 +475,65 @@ export function getModelPresets() {
   };
 }
 
+export function getModelRoleDefaults(overrides = {}) {
+  const presets = getModelPresets(overrides);
+  const spareProvider = overrides.spareProvider || process.env.AGINTI_SPARE_PROVIDER || "openai";
+  const spareModel = overrides.spareModel || process.env.AGINTI_SPARE_MODEL || "gpt-5.4";
+  const auxiliaryProvider = overrides.auxiliaryProvider || process.env.AGINTI_AUX_PROVIDER || "grsai";
+  const auxiliaryModel = overrides.auxiliaryModel || process.env.AGINTI_AUX_MODEL || process.env.VENICE_IMAGE_MODEL || "nano-banana-2";
+  return {
+    route: {
+      id: "route",
+      label: "Route model",
+      command: "/route",
+      provider: presets.fast.provider,
+      model: presets.fast.model,
+      description: "Fast planner and triage model. Default: DeepSeek V4 Flash.",
+    },
+    main: {
+      id: "main",
+      label: "Main model",
+      command: "/model",
+      provider: presets.complex.provider,
+      model: presets.complex.model,
+      description: "Complex executor for coding, debugging, writing, and long tasks. Default: DeepSeek V4 Pro.",
+    },
+    spare: {
+      id: "spare",
+      label: "Spare model",
+      command: "/spare",
+      provider: spareProvider,
+      model: spareModel,
+      reasoning: overrides.spareReasoning || process.env.AGINTI_SPARE_REASONING || "medium",
+      description: "Fallback or cross-check model. Default: OpenAI GPT-5.4 medium reasoning.",
+    },
+    wrapper: {
+      id: "wrapper",
+      label: "Wrapper",
+      command: "/wrapper",
+      provider: "codex",
+      model: presets.codexPrimary.model,
+      reasoning: presets.codexPrimary.reasoning,
+      description: "External coding wrapper when enabled. Default: Codex with GPT-5.5 medium reasoning.",
+    },
+    auxiliary: {
+      id: "auxiliary",
+      label: "Auxiliary",
+      command: "/auxilliary",
+      provider: auxiliaryProvider,
+      model: auxiliaryModel,
+      description: "Image/media tools. Default: GRS AI/Nano Banana; Venice image is optional.",
+    },
+  };
+}
+
+export function modelsForProviderGroup(groupId) {
+  const group = MODEL_PROVIDER_GROUPS[groupId];
+  if (!group) return [];
+  if (group.provider !== "venice") return PROVIDER_MODEL_CATALOG[group.provider] || [];
+  return (PROVIDER_MODEL_CATALOG.venice || []).filter((item) => item.bucket === groupId);
+}
+
 export function scoreTaskComplexity(goal = "", taskProfile = "auto") {
   const text = String(goal).toLowerCase();
   let score = text.length > 600 ? 2 : text.length > 240 ? 1 : 0;
@@ -399,10 +551,20 @@ export function normalizeRoutingMode(value) {
   return ROUTING_MODES.includes(value) ? value : "smart";
 }
 
-export function selectModelRoute({ routingMode = "smart", provider = "deepseek", model = "", goal = "", taskProfile = "auto" } = {}) {
+export function selectModelRoute({
+  routingMode = "smart",
+  provider = "deepseek",
+  model = "",
+  goal = "",
+  taskProfile = "auto",
+  routeProvider = "",
+  routeModel = "",
+  mainProvider = "",
+  mainModel = "",
+} = {}) {
   const mode = normalizeRoutingMode(routingMode);
   const requestedProvider = String(provider || "deepseek").toLowerCase();
-  const presets = getModelPresets();
+  const presets = getModelPresets({ routeProvider, routeModel, mainProvider, mainModel });
 
   if (requestedProvider === "mock") {
     const defaults = getProviderDefaults("mock");

package/src/tool-wrappers.js

@@ -52,7 +52,10 @@ function codexArgs(prompt, config, preset) {
 }
 
 function wrapperCommand(wrapper, prompt, config, { fallback = false } = {}) {
-  const presets = getModelPresets();
+  const presets = getModelPresets({
+    wrapperModel: config.wrapperModel,
+    wrapperReasoning: config.wrapperReasoning,
+  });
   switch (wrapper) {
     case "codex":
       return {

package/src/web-db.js

@@ -1,17 +1,29 @@
 import fs from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { getModelPresets } from "./model-routing.js";
+import { getModelPresets, getModelRoleDefaults } from "./model-routing.js";
 
-const PREFERENCES_SCHEMA_VERSION = 6;
+const PREFERENCES_SCHEMA_VERSION = 7;
 
 function defaultPreferences(baseDir) {
   const presets = getModelPresets();
+  const roles = getModelRoleDefaults();
   return {
     preferencesSchemaVersion: PREFERENCES_SCHEMA_VERSION,
     routingMode: "smart",
     provider: "deepseek",
     model: presets.fast.model,
+    routeProvider: roles.route.provider,
+    routeModel: roles.route.model,
+    mainProvider: roles.main.provider,
+    mainModel: roles.main.model,
+    spareProvider: roles.spare.provider,
+    spareModel: roles.spare.model,
+    spareReasoning: roles.spare.reasoning,
+    wrapperModel: roles.wrapper.model,
+    wrapperReasoning: roles.wrapper.reasoning,
+    auxiliaryProvider: roles.auxiliary.provider,
+    auxiliaryModel: roles.auxiliary.model,
     headless: true,
     maxSteps: 24,
     startUrl: "",
@@ -107,6 +119,20 @@ export class WebDatabase {
           preferences.allowParallelScouts = true;
           preferences.parallelScoutCount = 3;
         }
+        if ((parsed.preferencesSchemaVersion || 1) < 7) {
+          const roles = getModelRoleDefaults();
+          preferences.routeProvider = preferences.routeProvider || roles.route.provider;
+          preferences.routeModel = preferences.routeModel || roles.route.model;
+          preferences.mainProvider = preferences.mainProvider || roles.main.provider;
+          preferences.mainModel = preferences.mainModel || roles.main.model;
+          preferences.spareProvider = preferences.spareProvider || roles.spare.provider;
+          preferences.spareModel = preferences.spareModel || roles.spare.model;
+          preferences.spareReasoning = preferences.spareReasoning || roles.spare.reasoning;
+          preferences.wrapperModel = preferences.wrapperModel || roles.wrapper.model;
+          preferences.wrapperReasoning = preferences.wrapperReasoning || roles.wrapper.reasoning;
+          preferences.auxiliaryProvider = preferences.auxiliaryProvider || roles.auxiliary.provider;
+          preferences.auxiliaryModel = preferences.auxiliaryModel || roles.auxiliary.model;
+        }
         this.savePreferences(preferences);
       }
       return preferences;

package/web.js

@@ -6,7 +6,15 @@ import { runAgent } from "./src/agent-runner.js";
 import { resolveRuntimeConfig } from "./src/config.js";
 import { WebDatabase } from "./src/web-db.js";
 import { SessionStore } from "./src/session-store.js";
-import { PROVIDER_MODEL_CATALOG, getModelPresets, getProviderDefaults, normalizeRoutingMode } from "./src/model-routing.js";
+import {
+  AUXILIARY_MODEL_CATALOG,
+  MODEL_PROVIDER_GROUPS,
+  PROVIDER_MODEL_CATALOG,
+  getModelPresets,
+  getModelRoleDefaults,
+  getProviderDefaults,
+  normalizeRoutingMode,
+} from "./src/model-routing.js";
 import { listAgentWrappers, normalizeWrapperName } from "./src/tool-wrappers.js";
 import { getDockerSandboxStatus, getSandboxLogs, runDockerPreflight } from "./src/docker-sandbox.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./src/command-policy.js";
@@ -113,6 +121,7 @@ function serializeRun(run) {
 
 function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
   const modelPresets = getModelPresets();
+  const modelRoles = getModelRoleDefaults();
   const providerCandidate = body.provider || current.provider || "deepseek";
   const provider = ["openai", "deepseek", "qwen", "venice", "mock"].includes(providerCandidate) ? providerCandidate : "deepseek";
   const routingMode =
@@ -132,6 +141,50 @@ function normalizePreferencePayload(body = {}, current = db.getPreferences()) {
         : current.provider !== provider
           ? providerDefaults.model
           : current.model || modelPresets.fast.model || providerDefaults.model,
+    routeProvider:
+      typeof body.routeProvider === "string" && body.routeProvider.trim()
+        ? body.routeProvider.trim()
+        : current.routeProvider || modelRoles.route.provider,
+    routeModel:
+      typeof body.routeModel === "string" && body.routeModel.trim()
+        ? body.routeModel.trim()
+        : current.routeModel || modelRoles.route.model,
+    mainProvider:
+      typeof body.mainProvider === "string" && body.mainProvider.trim()
+        ? body.mainProvider.trim()
+        : current.mainProvider || modelRoles.main.provider,
+    mainModel:
+      typeof body.mainModel === "string" && body.mainModel.trim()
+        ? body.mainModel.trim()
+        : current.mainModel || modelRoles.main.model,
+    spareProvider:
+      typeof body.spareProvider === "string" && body.spareProvider.trim()
+        ? body.spareProvider.trim()
+        : current.spareProvider || modelRoles.spare.provider,
+    spareModel:
+      typeof body.spareModel === "string" && body.spareModel.trim()
+        ? body.spareModel.trim()
+        : current.spareModel || modelRoles.spare.model,
+    spareReasoning:
+      typeof body.spareReasoning === "string" && body.spareReasoning.trim()
+        ? body.spareReasoning.trim()
+        : current.spareReasoning || modelRoles.spare.reasoning,
+    wrapperModel:
+      typeof body.wrapperModel === "string" && body.wrapperModel.trim()
+        ? body.wrapperModel.trim()
+        : current.wrapperModel || modelRoles.wrapper.model,
+    wrapperReasoning:
+      typeof body.wrapperReasoning === "string" && body.wrapperReasoning.trim()
+        ? body.wrapperReasoning.trim()
+        : current.wrapperReasoning || modelRoles.wrapper.reasoning,
+    auxiliaryProvider:
+      typeof body.auxiliaryProvider === "string" && body.auxiliaryProvider.trim()
+        ? body.auxiliaryProvider.trim()
+        : current.auxiliaryProvider || modelRoles.auxiliary.provider,
+    auxiliaryModel:
+      typeof body.auxiliaryModel === "string" && body.auxiliaryModel.trim()
+        ? body.auxiliaryModel.trim()
+        : current.auxiliaryModel || modelRoles.auxiliary.model,
     headless: typeof body.headless === "boolean" ? body.headless : Boolean(current.headless),
     maxSteps: Number.isFinite(parsedMaxSteps) && parsedMaxSteps > 0 ? parsedMaxSteps : Number(current.maxSteps) || 24,
     startUrl: typeof body.startUrl === "string" ? body.startUrl.trim() : current.startUrl || "",
@@ -223,6 +276,17 @@ function buildRunConfig(body, overrides = {}) {
       provider: merged.provider,
       model: merged.model || getProviderDefaults(merged.provider).model,
       routingMode: merged.routingMode,
+      routeProvider: merged.routeProvider,
+      routeModel: merged.routeModel,
+      mainProvider: merged.mainProvider,
+      mainModel: merged.mainModel,
+      spareProvider: merged.spareProvider,
+      spareModel: merged.spareModel,
+      spareReasoning: merged.spareReasoning,
+      wrapperModel: merged.wrapperModel,
+      wrapperReasoning: merged.wrapperReasoning,
+      auxiliaryProvider: merged.auxiliaryProvider,
+      auxiliaryModel: merged.auxiliaryModel,
       headless: merged.headless,
       maxSteps: merged.maxSteps,
       allowedDomains: String(merged.allowedDomains || "")
@@ -586,6 +650,9 @@ app.get("/api/config", async (_req, res) => {
       maxSteps: 24,
     },
     modelCatalog: PROVIDER_MODEL_CATALOG,
+    modelGroups: MODEL_PROVIDER_GROUPS,
+    auxiliaryModelCatalog: AUXILIARY_MODEL_CATALOG,
+    modelRoles: getModelRoleDefaults(preferences),
     taskProfiles: listTaskProfiles(),
     skills: listSkills(),
     routing: {