@lazyingart/agintiflow 0.18.0 → 0.19.0

package/README.md

@@ -77,6 +77,8 @@ Inside chat, type normal requests such as `write a small Python CLI app with tes
 
 For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSeek v4 pro by default and exposes `apply_patch` as a deterministic workspace tool. It supports exact replacements, Codex-style patch envelopes, and unified diffs, with preflight checks, path guardrails, hashes, and compact per-file diffs. See [docs/patch-tools.md](docs/patch-tools.md).
 
+Model choice is role-based: `/route` defaults to DeepSeek V4 Flash, `/model` or `/main` defaults to DeepSeek V4 Pro, `/spare` defaults to OpenAI GPT-5.4 medium, `/wrapper` defaults to Codex GPT-5.5 medium when enabled, and `/auxilliary` defaults to GRS AI/Nano Banana for image tools. See [docs/model-selection.md](docs/model-selection.md) and run `aginti models`.
+
 For larger repositories, use `--profile large-codebase` or choose **Large codebase engineering** in the web UI. The web default stays **Auto**, and Auto now escalates codebase/system/debugging prompts to the same engineering loop when needed. Complex work routes to DeepSeek v4 pro, starts with `inspect_project`, then uses search/read/patch/check loops inspired by Codex, Copilot SDK, Claude Code, Gemini CLI, Qwen, and Claw Code. See [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md).
 
 AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. It first writes a bounded project map to `.aginti/codebase-map.json`, then runs scouts for architecture, implementation, review, research, context mapping, tests, git workflow, integration, symbol tracing, and dependency risks. A coordinator Swarm Board is injected for the main agent and saved as `artifacts/scout-blackboard.json` in the session. The executor still does the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..10`.

package/docs/model-selection.md

@@ -0,0 +1,70 @@
+# Model Selection
+
+AgInTiFlow treats model choice as a role-based control plane. A provider supplies models; a role decides how the agent uses one.
+
+## Default Roles
+
+| Role | CLI command | Default | Purpose |
+| --- | --- | --- | --- |
+| Route | `/route` | `deepseek/deepseek-v4-flash` | Fast planner, triage, short tasks, and routing decisions. |
+| Main | `/model` or `/main` | `deepseek/deepseek-v4-pro` | Complex executor for coding, debugging, writing, and long tasks. |
+| Spare | `/spare` | `openai/gpt-5.4` with `medium` reasoning | Optional fallback or cross-check model. |
+| Wrapper | `/wrapper` | `codex gpt-5.5 medium` | External coding assistant when wrapper tools are enabled. |
+| Auxiliary | `/auxilliary` | `grsai/nano-banana-2` | Image/media tools; Venice image models are optional. |
+
+Smart routing still works as before: normal work goes to the route model, and complex work goes to the main model. Manual provider/model selection remains available for one-off runs.
+
+## CLI Commands
+
+```bash
+aginti models
+aginti --list-models
+aginti --list-routes
+
+# one-shot overrides
+aginti --route-model deepseek-v4-flash --main-model deepseek-v4-pro "fix this project"
+aginti --provider venice --model venice-uncensored-1-2 --routing manual "draft a note"
+aginti --spare-provider openai --spare-model gpt-5.4 --spare-reasoning medium "review this design"
+aginti --allow-wrappers --wrapper codex --wrapper-model gpt-5.5 "patch this bug"
+aginti --image --aux-provider venice --aux-model gpt-image-2 "generate a logo"
+```
+
+Interactive commands:
+
+```text
+/models
+/route deepseek/deepseek-v4-flash
+/model deepseek/deepseek-v4-pro
+/spare openai/gpt-5.4 medium
+/wrapper codex gpt-5.5 medium
+/auxilliary model grsai/nano-banana-2
+```
+
+## Provider Buckets
+
+| Bucket | Provider | Typical use |
+| --- | --- | --- |
+| `deepseek` | DeepSeek | Default route/main because V4 Flash and V4 Pro are cheap and strong. |
+| `openai` | OpenAI | Spare/frontier checks, Codex-family work, and explicit manual routes. |
+| `qwen` | Qwen | Chinese and general-purpose OpenAI-compatible tasks. |
+| `venice-uncensored` | Venice | Venice-native uncensored text models. |
+| `venice-gpt` | Venice | GPT-family models through Venice. |
+| `venice-claude` | Venice | Claude-family models through Venice. |
+| `venice-gemma` | Venice | Gemma-family models through Venice. |
+| `venice-qwen` | Venice | Qwen-family models through Venice. |
+| `venice-image` | Venice | Image generation/editing such as Nano Banana, GPT Image, Wan, Qwen Image. |
+| `grsai` | GRS AI | Auxiliary image generation only. |
+
+## Keys
+
+Keys are set per project and stored only in ignored `.aginti/.env`:
+
+```bash
+aginti auth
+aginti auth venice
+aginti keys status
+printf '%s' "$VENICE_API_KEY" | aginti keys set venice --stdin
+```
+
+The web UI mirrors the same roles in its **Model roles** panel. Use the top provider/model fields for manual runs; use the role fields to change how smart routing chooses route, main, spare, wrapper, and auxiliary models.
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "type": "module",
   "description": "AgInTiFlow is a web-first coding agent and CLI with DeepSeek routing, sandboxed tools, model providers, canvas artifacts, and optional wrappers.",
   "license": "Apache-2.0",
@@ -52,6 +52,7 @@
     "scripts/smoke-coding-tools.js",
     "scripts/smoke-capabilities.js",
     "scripts/smoke-inbox.js",
+    "scripts/smoke-model-roles.js",
     "scripts/smoke-platform.js",
     "scripts/smoke-skills.js",
     "scripts/smoke-tmux-tools.js",
@@ -78,11 +79,12 @@
     "smoke:skills": "node scripts/smoke-skills.js",
     "smoke:toolchain-docker": "node scripts/smoke-toolchain-docker.js",
     "smoke:inbox": "node scripts/smoke-inbox.js",
+    "smoke:model-roles": "node scripts/smoke-model-roles.js",
     "smoke:platform": "node scripts/smoke-platform.js",
     "smoke:tmux-tools": "node scripts/smoke-tmux-tools.js",
     "smoke:web-api": "node scripts/smoke-web-api.js",
     "real:deepseek": "node scripts/real-deepseek-capabilities.js",
-    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:auxiliary-tools && npm run smoke:auth && npm run smoke:capabilities && npm run smoke:platform && npm run smoke:skills && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
+    "test": "npm run check && npm run smoke:web-api && npm run smoke:coding-tools && npm run smoke:auxiliary-tools && npm run smoke:auth && npm run smoke:capabilities && npm run smoke:model-roles && npm run smoke:platform && npm run smoke:skills && npm run smoke:tmux-tools && npm run smoke:cli-chat && npm run smoke:inbox",
     "pack:dry-run": "npm pack --dry-run",
     "smoke:capabilities": "node scripts/smoke-capabilities.js"
   },

package/public/app.js

@@ -651,7 +651,19 @@ const providerField = document.querySelector("#provider");
 const modelField = document.querySelector("#model");
 const modelOptionsEl = document.querySelector("#model-options");
 const modelCatalogEl = document.querySelector("#model-catalog");
+const modelRoleGridEl = document.querySelector("#model-role-grid");
 const modelRoutePillEl = document.querySelector("#model-route-pill");
+const routeProviderField = document.querySelector("#routeProvider");
+const routeModelField = document.querySelector("#routeModel");
+const mainProviderField = document.querySelector("#mainProvider");
+const mainModelField = document.querySelector("#mainModel");
+const spareProviderField = document.querySelector("#spareProvider");
+const spareModelField = document.querySelector("#spareModel");
+const spareReasoningField = document.querySelector("#spareReasoning");
+const wrapperModelField = document.querySelector("#wrapperModel");
+const wrapperReasoningField = document.querySelector("#wrapperReasoning");
+const auxiliaryProviderField = document.querySelector("#auxiliaryProvider");
+const auxiliaryModelField = document.querySelector("#auxiliaryModel");
 const routingHintEl = document.querySelector("#routing-hint");
 const modelRouteStatusEl = document.querySelector("#model-route-status");
 const projectStatusEl = document.querySelector("#project-status");
@@ -728,6 +740,9 @@ const defaults = {
 let currentLanguage = "en";
 let routingPresets = {};
 let modelCatalog = {};
+let modelRoles = {};
+let modelGroups = {};
+let auxiliaryModelCatalog = {};
 let taskProfiles = [];
 let projectInfo = null;
 let currentSessionId = "";
@@ -970,6 +985,50 @@ function providerModelOptions(provider = providerField.value) {
   return modelCatalog[provider] || [];
 }
 
+function renderModelRoles() {
+  if (!modelRoleGridEl) return;
+  const roles = {
+    route: {
+      ...(modelRoles.route || {}),
+      provider: routeProviderField?.value || modelRoles.route?.provider || "deepseek",
+      model: routeModelField?.value || modelRoles.route?.model || "deepseek-v4-flash",
+    },
+    main: {
+      ...(modelRoles.main || {}),
+      provider: mainProviderField?.value || modelRoles.main?.provider || "deepseek",
+      model: mainModelField?.value || modelRoles.main?.model || "deepseek-v4-pro",
+    },
+    spare: {
+      ...(modelRoles.spare || {}),
+      provider: spareProviderField?.value || modelRoles.spare?.provider || "openai",
+      model: spareModelField?.value || modelRoles.spare?.model || "gpt-5.4",
+      reasoning: spareReasoningField?.value || modelRoles.spare?.reasoning || "medium",
+    },
+    wrapper: {
+      ...(modelRoles.wrapper || {}),
+      provider: preferredWrapperField?.value || modelRoles.wrapper?.provider || "codex",
+      model: wrapperModelField?.value || modelRoles.wrapper?.model || "gpt-5.5",
+      reasoning: wrapperReasoningField?.value || modelRoles.wrapper?.reasoning || "medium",
+    },
+    auxiliary: {
+      ...(modelRoles.auxiliary || {}),
+      provider: auxiliaryProviderField?.value || modelRoles.auxiliary?.provider || "grsai",
+      model: auxiliaryModelField?.value || modelRoles.auxiliary?.model || "nano-banana-2",
+    },
+  };
+  modelRoleGridEl.innerHTML = Object.values(roles)
+    .map((role) => {
+      const reasoning = role.reasoning ? ` · ${role.reasoning}` : "";
+      return `
+        <div class="model-role-card">
+          <strong>${escapeHtml(role.label || role.id)}</strong>
+          <span>${escapeHtml(`${role.provider}/${role.model}${reasoning}`)}</span>
+        </div>
+      `;
+    })
+    .join("");
+}
+
 function renderModelOptions() {
   const provider = providerField.value || "deepseek";
   const options = providerModelOptions(provider);
@@ -981,11 +1040,12 @@ function renderModelOptions() {
   if (modelRoutePillEl) {
     const mode = routingModeField.value || "smart";
     const primary = modelField.value.trim() || defaults[provider] || "";
-    const secondary = provider === "deepseek" ? defaults.deepseek : routingPresets.complex?.model || "deepseek-v4-pro";
+    const routeLabel = `${routeProviderField?.value || "deepseek"}/${routeModelField?.value || "deepseek-v4-flash"}`;
+    const mainLabel = `${mainProviderField?.value || "deepseek"}/${mainModelField?.value || "deepseek-v4-pro"}`;
     modelRoutePillEl.textContent =
       mode === "manual"
         ? `${provider} · ${primary}`
-        : `smart · primary ${primary || "auto"} · secondary ${secondary || "auto"}`;
+        : `${mode} · route ${routeLabel} · main ${mainLabel}`;
   }
   if (!modelCatalogEl) return;
   if (options.length === 0) {
@@ -1002,6 +1062,7 @@ function renderModelOptions() {
       `
     )
     .join("");
+  renderModelRoles();
 }
 
 function updateRoutingHint() {
@@ -1015,7 +1076,16 @@ function updateRoutingHint() {
   routingHintEl.textContent = t(hintKey);
 
   if (mode !== "manual" && providerField.value === "deepseek") {
-    const preset = mode === "complex" ? routingPresets.complex : routingPresets.fast;
+    const preset =
+      mode === "complex"
+        ? {
+            provider: mainProviderField?.value || routingPresets.complex?.provider,
+            model: mainModelField?.value || routingPresets.complex?.model,
+          }
+        : {
+            provider: routeProviderField?.value || routingPresets.fast?.provider,
+            model: routeModelField?.value || routingPresets.fast?.model,
+          };
     if (preset) {
       providerField.value = preset.provider === "deepseek" ? "deepseek" : providerField.value;
       modelField.value = preset.model || modelField.value;
@@ -1083,6 +1153,17 @@ function formPayload() {
     routingMode: routingModeField.value,
     provider: providerField.value,
     model: modelField.value.trim(),
+    routeProvider: routeProviderField?.value || "deepseek",
+    routeModel: routeModelField?.value.trim() || "deepseek-v4-flash",
+    mainProvider: mainProviderField?.value || "deepseek",
+    mainModel: mainModelField?.value.trim() || "deepseek-v4-pro",
+    spareProvider: spareProviderField?.value || "openai",
+    spareModel: spareModelField?.value.trim() || "gpt-5.4",
+    spareReasoning: spareReasoningField?.value || "medium",
+    wrapperModel: wrapperModelField?.value.trim() || "gpt-5.5",
+    wrapperReasoning: wrapperReasoningField?.value || "medium",
+    auxiliaryProvider: auxiliaryProviderField?.value || "grsai",
+    auxiliaryModel: auxiliaryModelField?.value.trim() || "nano-banana-2",
     startUrl: document.querySelector("#startUrl").value.trim(),
     allowedDomains: document.querySelector("#allowedDomains").value.trim(),
     commandCwd: document.querySelector("#commandCwd").value.trim(),
@@ -2366,6 +2447,18 @@ modelCatalogEl?.addEventListener("click", (event) => {
 });
 
 modelField.addEventListener("input", updateRoutingHint);
+[routeProviderField, routeModelField, mainProviderField, mainModelField, spareProviderField, spareModelField, spareReasoningField, wrapperModelField, wrapperReasoningField, auxiliaryProviderField, auxiliaryModelField]
+  .filter(Boolean)
+  .forEach((field) => {
+    field.addEventListener("input", () => {
+      renderModelRoles();
+      schedulePreferenceSave();
+    });
+    field.addEventListener("change", () => {
+      renderModelRoles();
+      schedulePreferenceSave();
+    });
+  });
 sandboxModeField.addEventListener("change", updatePackageWarning);
 packageInstallPolicyField.addEventListener("change", updatePackageWarning);
 allowWrapperToolsField.addEventListener("change", () => renderWrapperStatus());
@@ -2590,6 +2683,9 @@ async function loadConfig() {
   const prefs = data.preferences || {};
   routingPresets = data.routing?.presets || {};
   modelCatalog = data.modelCatalog || {};
+  modelRoles = data.modelRoles || {};
+  modelGroups = data.modelGroups || {};
+  auxiliaryModelCatalog = data.auxiliaryModelCatalog || {};
   taskProfiles = data.taskProfiles || [];
   projectInfo = data.project || null;
   defaults.openai = data.defaults?.openai?.model || defaults.openai;
@@ -2603,6 +2699,17 @@ async function loadConfig() {
   routingModeField.value = prefs.routingMode || "smart";
   providerField.value = prefs.provider || "deepseek";
   modelField.value = prefs.model || defaults[providerField.value] || "deepseek-v4-flash";
+  if (routeProviderField) routeProviderField.value = prefs.routeProvider || modelRoles.route?.provider || "deepseek";
+  if (routeModelField) routeModelField.value = prefs.routeModel || modelRoles.route?.model || "deepseek-v4-flash";
+  if (mainProviderField) mainProviderField.value = prefs.mainProvider || modelRoles.main?.provider || "deepseek";
+  if (mainModelField) mainModelField.value = prefs.mainModel || modelRoles.main?.model || "deepseek-v4-pro";
+  if (spareProviderField) spareProviderField.value = prefs.spareProvider || modelRoles.spare?.provider || "openai";
+  if (spareModelField) spareModelField.value = prefs.spareModel || modelRoles.spare?.model || "gpt-5.4";
+  if (spareReasoningField) spareReasoningField.value = prefs.spareReasoning || modelRoles.spare?.reasoning || "medium";
+  if (wrapperModelField) wrapperModelField.value = prefs.wrapperModel || modelRoles.wrapper?.model || "gpt-5.5";
+  if (wrapperReasoningField) wrapperReasoningField.value = prefs.wrapperReasoning || modelRoles.wrapper?.reasoning || "medium";
+  if (auxiliaryProviderField) auxiliaryProviderField.value = prefs.auxiliaryProvider || modelRoles.auxiliary?.provider || "grsai";
+  if (auxiliaryModelField) auxiliaryModelField.value = prefs.auxiliaryModel || modelRoles.auxiliary?.model || "nano-banana-2";
   renderTaskProfiles(prefs.taskProfile || "auto");
   document.querySelector("#startUrl").value = prefs.startUrl || "";
   document.querySelector("#allowedDomains").value = prefs.allowedDomains || "";

package/public/index.html

@@ -118,9 +118,74 @@
               <span>Route</span>
               <strong id="model-route-pill">DeepSeek flash/pro</strong>
             </div>
+            <div id="model-role-grid" class="model-role-grid"></div>
             <div id="model-catalog" class="model-catalog"></div>
           </section>
 
+          <section class="model-role-editor" aria-label="Model role settings">
+            <div class="model-role-editor-head">
+              <strong>Model roles</strong>
+              <span>Route, main, spare, wrapper, auxiliary</span>
+            </div>
+            <div class="role-editor-grid">
+              <label>
+                <span>Route</span>
+                <select id="routeProvider" name="routeProvider">
+                  <option value="deepseek">DeepSeek</option>
+                  <option value="openai">OpenAI</option>
+                  <option value="qwen">Qwen</option>
+                  <option value="venice">Venice</option>
+                  <option value="mock">Mock</option>
+                </select>
+                <input id="routeModel" name="routeModel" type="text" placeholder="deepseek-v4-flash" />
+              </label>
+              <label>
+                <span>Main</span>
+                <select id="mainProvider" name="mainProvider">
+                  <option value="deepseek">DeepSeek</option>
+                  <option value="openai">OpenAI</option>
+                  <option value="qwen">Qwen</option>
+                  <option value="venice">Venice</option>
+                </select>
+                <input id="mainModel" name="mainModel" type="text" placeholder="deepseek-v4-pro" />
+              </label>
+              <label>
+                <span>Spare</span>
+                <select id="spareProvider" name="spareProvider">
+                  <option value="openai">OpenAI</option>
+                  <option value="deepseek">DeepSeek</option>
+                  <option value="qwen">Qwen</option>
+                  <option value="venice">Venice</option>
+                </select>
+                <input id="spareModel" name="spareModel" type="text" placeholder="gpt-5.4" />
+                <select id="spareReasoning" name="spareReasoning">
+                  <option value="low">low</option>
+                  <option value="medium">medium</option>
+                  <option value="high">high</option>
+                  <option value="xhigh">xhigh</option>
+                </select>
+              </label>
+              <label>
+                <span>Wrapper</span>
+                <input id="wrapperModel" name="wrapperModel" type="text" placeholder="gpt-5.5" />
+                <select id="wrapperReasoning" name="wrapperReasoning">
+                  <option value="low">low</option>
+                  <option value="medium">medium</option>
+                  <option value="high">high</option>
+                  <option value="xhigh">xhigh</option>
+                </select>
+              </label>
+              <label>
+                <span>Auxiliary</span>
+                <select id="auxiliaryProvider" name="auxiliaryProvider">
+                  <option value="grsai">GRS AI</option>
+                  <option value="venice">Venice image</option>
+                </select>
+                <input id="auxiliaryModel" name="auxiliaryModel" type="text" placeholder="nano-banana-2" />
+              </label>
+            </div>
+          </section>
+
           <label>
             <span data-i18n="taskProfileLabel">Task profile</span>
             <select id="taskProfile" name="taskProfile">

package/public/styles.css

@@ -157,6 +157,82 @@ h1 {
   gap: 8px;
 }
 
+.model-role-grid {
+  display: grid;
+  gap: 8px;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.model-role-card {
+  min-width: 0;
+  padding: 10px;
+  border: 1px solid rgba(15, 118, 110, 0.18);
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.model-role-card strong,
+.model-role-card span {
+  display: block;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.model-role-card strong {
+  color: #0f766e;
+  font-size: 0.84rem;
+}
+
+.model-role-card span {
+  color: var(--muted);
+  font-size: 0.76rem;
+}
+
+.model-role-editor {
+  display: grid;
+  gap: 10px;
+  margin-top: -2px;
+  padding: 12px;
+  border: 1px solid rgba(29, 78, 216, 0.14);
+  border-radius: 16px;
+  background:
+    linear-gradient(135deg, rgba(219, 234, 254, 0.62), rgba(255, 251, 235, 0.82)),
+    rgba(255, 255, 255, 0.82);
+}
+
+.model-role-editor-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 10px;
+  color: var(--muted);
+  font-size: 0.78rem;
+}
+
+.model-role-editor-head strong {
+  color: #1d4ed8;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+}
+
+.role-editor-grid {
+  display: grid;
+  gap: 10px;
+}
+
+.role-editor-grid label {
+  display: grid;
+  gap: 6px;
+}
+
+.role-editor-grid label > span {
+  color: var(--muted);
+  font-size: 0.74rem;
+  font-weight: 800;
+  letter-spacing: 0.07em;
+  text-transform: uppercase;
+}
+
 .model-chip {
   display: grid;
   gap: 2px;

package/references/model-routing-provider-design.md

@@ -14,13 +14,40 @@ DeepSeek remains the default smart-route backend:
 
 If the user selects OpenAI, Qwen, or Venice as the provider, AgInTiFlow treats that as the primary manual provider even when the UI still shows a smart policy. This makes provider selection predictable while preserving DeepSeek as the default.
 
-## Provider Sections
+## Role-Based Model Sections
 
-The web UI should show three ideas clearly:
+The UI should be role-first rather than provider-first:
 
-- **Route:** smart, fast, complex, or manual.
-- **Primary:** the provider/model currently used for the next run.
-- **Secondary:** the fallback/escalation route, usually DeepSeek V4 Pro or a wrapper such as Codex.
+- **Route model (`/route`):** fast planner and triage model. Default `deepseek/deepseek-v4-flash`.
+- **Main model (`/model` or `/main`):** complex executor. Default `deepseek/deepseek-v4-pro`.
+- **Spare model (`/spare`):** fallback/cross-check model. Default `openai/gpt-5.4` with `medium` reasoning.
+- **Wrapper (`/wrapper`):** external coding assistant. Default Codex with `gpt-5.5` medium reasoning, disabled unless wrapper tools are enabled.
+- **Auxiliary (`/auxilliary`):** media/image tools. Default `grsai/nano-banana-2`; Venice image models are optional.
+
+This keeps the mental model stable: providers are supply, roles are policy.
+
+## Current Commands
+
+```bash
+aginti models
+aginti --list-models
+aginti --list-routes
+aginti --route-model deepseek-v4-flash --main-model deepseek-v4-pro "fix this project"
+aginti --spare-provider openai --spare-model gpt-5.4 --spare-reasoning medium "review this patch"
+aginti --allow-wrappers --wrapper codex --wrapper-model gpt-5.5 "use Codex as a helper"
+aginti --image --aux-provider venice --aux-model gpt-image-2 "generate an image"
+```
+
+Interactive equivalents:
+
+```text
+/models
+/route deepseek/deepseek-v4-flash
+/model deepseek/deepseek-v4-pro
+/spare openai/gpt-5.4 medium
+/wrapper codex gpt-5.5 medium
+/auxilliary model grsai/nano-banana-2
+```
 
 ## OpenAI Model Reference
 

package/scripts/smoke-model-roles.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  AUXILIARY_MODEL_CATALOG,
+  MODEL_PROVIDER_GROUPS,
+  getModelRoleDefaults,
+  modelsForProviderGroup,
+  selectModelRoute,
+} from "../src/model-routing.js";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message);
+}
+
+function runCli(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [path.join(repoRoot, "bin/aginti-cli.js"), ...args], {
+      cwd: repoRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error("model role CLI smoke timed out"));
+    }, 12000);
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve(stdout);
+      else reject(new Error(`model role CLI smoke failed ${code}\n${stdout}\n${stderr}`));
+    });
+  });
+}
+
+const roles = getModelRoleDefaults();
+assert(roles.route.provider === "deepseek", "route provider default should be deepseek");
+assert(roles.route.model === "deepseek-v4-flash", "route model default should be deepseek-v4-flash");
+assert(roles.main.model === "deepseek-v4-pro", "main model default should be deepseek-v4-pro");
+assert(roles.spare.provider === "openai" && roles.spare.model === "gpt-5.4", "spare model default should be OpenAI GPT-5.4");
+assert(roles.wrapper.provider === "codex" && roles.wrapper.model === "gpt-5.5", "wrapper default should be Codex GPT-5.5");
+assert(roles.auxiliary.provider === "grsai" && roles.auxiliary.model === "nano-banana-2", "auxiliary default should be GRS AI Nano Banana");
+
+const complexRoute = selectModelRoute({
+  routingMode: "complex",
+  provider: "deepseek",
+  mainModel: "deepseek-v4-pro",
+});
+assert(complexRoute.model === "deepseek-v4-pro", "complex route did not use main model override");
+
+const fastRoute = selectModelRoute({
+  routingMode: "fast",
+  provider: "deepseek",
+  routeModel: "deepseek-v4-flash",
+});
+assert(fastRoute.model === "deepseek-v4-flash", "fast route did not use route model override");
+
+assert(MODEL_PROVIDER_GROUPS["venice-gpt"].provider === "venice", "venice-gpt group missing");
+assert(modelsForProviderGroup("venice-gemma").some((item) => item.id === "gemma-4-uncensored"), "venice-gemma bucket missing Gemma");
+assert(AUXILIARY_MODEL_CATALOG["venice-image"].some((item) => item.id === "gpt-image-2"), "Venice image catalog missing GPT Image 2");
+
+const output = await runCli(["models"]);
+assert(output.includes("/route") && output.includes("/spare") && output.includes("venice-gpt"), "aginti models output missing role details");
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      checks: ["role-defaults", "route-overrides", "provider-groups", "auxiliary-catalog", "cli-models-command"],
+    },
+    null,
+    2
+  )
+);

package/scripts/smoke-web-api.js

@@ -87,6 +87,12 @@ try {
   if (!config.modelCatalog?.venice?.some((model) => model.id === "venice-uncensored-1-2")) {
     throw new Error("venice model catalog is not advertised by /api/config");
   }
+  if (config.modelRoles?.route?.model !== "deepseek-v4-flash" || config.modelRoles?.main?.model !== "deepseek-v4-pro") {
+    throw new Error("model role defaults are not advertised by /api/config");
+  }
+  if (!config.modelGroups?.["venice-gpt"] || !config.auxiliaryModelCatalog?.["venice-image"]) {
+    throw new Error("model provider groups are not advertised by /api/config");
+  }
 
   const keyStatus = await fetchJson("/api/keys/status");
   if (typeof keyStatus.keyStatus?.deepseek !== "boolean") throw new Error("key status endpoint is invalid");
@@ -149,6 +155,12 @@ try {
       provider: "mock",
       routingMode: "manual",
       model: "mock-agent",
+      routeModel: "deepseek-v4-flash",
+      mainModel: "deepseek-v4-pro",
+      spareProvider: "openai",
+      spareModel: "gpt-5.4",
+      auxiliaryProvider: "grsai",
+      auxiliaryModel: "nano-banana-2",
       goal: "Report the current working directory with a safe command.",
       commandCwd: runtimeDir,
       sandboxMode: "host",

package/src/auxiliary-tools.js

@@ -252,10 +252,16 @@ function resultUrls(payload) {
 
 function normalizeImageProvider(value = "") {
   const normalized = String(value || "").trim().toLowerCase();
-  if (["venice", "venice-ai", "veniceai"].includes(normalized)) return "venice";
+  if (["venice", "venice-image", "venice-ai", "veniceai"].includes(normalized)) return "venice";
   return "grsai";
 }
 
+function defaultImageProvider(config = {}) {
+  return normalizeImageProvider(
+    config.auxiliaryProvider || process.env.AGINTI_AUX_PROVIDER || process.env.VENICE_IMAGE_PROVIDER || process.env.GRSAI_IMAGE_PROVIDER || ""
+  );
+}
+
 function veniceBaseUrl(value = "") {
   return String(value || process.env.VENICE_API_BASE || process.env.VENICE_BASE_URL || DEFAULT_VENICE_BASE)
     .trim()
@@ -268,7 +274,9 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
     throw new Error("Missing VENICE_API_KEY. Run `aginti login venice` or `aginti keys set venice --stdin`.");
   }
 
-  const model = String(args.model || process.env.VENICE_IMAGE_MODEL || DEFAULT_VENICE_IMAGE_MODEL).trim() || DEFAULT_VENICE_IMAGE_MODEL;
+  const model =
+    String(args.model || process.env.AGINTI_AUX_MODEL || process.env.VENICE_IMAGE_MODEL || DEFAULT_VENICE_IMAGE_MODEL).trim() ||
+    DEFAULT_VENICE_IMAGE_MODEL;
   const format = String(args.format || "png").trim().toLowerCase() === "webp" ? "webp" : "png";
   const sizing = veniceSizingForModel(model, args);
   const payload = {
@@ -356,12 +364,13 @@ export async function generateImage(args = {}, config = {}) {
     if (converted.url) references.push(converted);
   }
 
-  const provider = normalizeImageProvider(args.provider || "");
+  const provider = args.provider ? normalizeImageProvider(args.provider) : defaultImageProvider(config);
   const host = provider === "venice" ? veniceBaseUrl(args.host) : String(args.host || DEFAULT_GRS_HOST).trim().replace(/\/+$/, "") || DEFAULT_GRS_HOST;
   const model =
     provider === "venice"
-      ? String(args.model || process.env.VENICE_IMAGE_MODEL || DEFAULT_VENICE_IMAGE_MODEL).trim() || DEFAULT_VENICE_IMAGE_MODEL
-      : String(args.model || DEFAULT_IMAGE_MODEL).trim() || DEFAULT_IMAGE_MODEL;
+      ? String(args.model || config.auxiliaryModel || process.env.AGINTI_AUX_MODEL || process.env.VENICE_IMAGE_MODEL || DEFAULT_VENICE_IMAGE_MODEL).trim() ||
+        DEFAULT_VENICE_IMAGE_MODEL
+      : String(args.model || config.auxiliaryModel || process.env.AGINTI_AUX_MODEL || DEFAULT_IMAGE_MODEL).trim() || DEFAULT_IMAGE_MODEL;
   const outputStem = safeStem(args.outputStem || "image");
   const payload = {
     model,