@lazyingart/agintiflow 0.20.184 → 0.20.185

package/docs/auxiliary-image-generation.md

@@ -7,6 +7,10 @@ AgInTiFlow separates **skills** from **tools**:
 
 The optional image-generation skills are `image_generation` and `venice_image_generation`. Both use the deterministic `generate_image` tool.
 
+`generate_image` is a raster-image tool. It does not produce true SVG/vector output. If a caller requests `svg`, the tool records
+`requestedFormat: "svg"`, generates a PNG fallback with `actualFormat: "png"`, and returns a `formatNotice`. If the task truly requires
+editable vectors, use AgInTiFlow file tools to write deterministic SVG/LaTeX/HTML instead of calling `generate_image`.
+
 ## Setup
 
 Store a GRS AI or Venice key project-locally:
@@ -38,11 +42,39 @@ For image, cover, poster, illustration, photo, or logo-concept requests, the mod
   "model": "nano-banana-2",
   "outputDir": "artifacts/images/robot-cover",
   "outputStem": "robot-cover",
+  "format": "png",
   "aspectRatio": "1:1",
   "imageSize": "2K"
 }
 ```
 
+For trusted local apps that need image generation without routing through a language-model run, the web server exposes a deterministic endpoint:
+
+```bash
+curl -sS http://127.0.0.1:3210/api/auxiliary/generate-image \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "prompt": "A polished cyan robot painting a circuit-board river",
+    "provider": "venice",
+    "format": "svg",
+    "outputDir": "artifacts/images/robot-cover",
+    "outputStem": "robot-cover"
+  }'
+```
+
+This endpoint is intended for trusted local/server-side callers. Browser apps on another origin should use an explicit adapter/proxy
+rather than relying on permissive CORS, because generation can consume API keys and write workspace artifacts.
+
+That SVG request returns a PNG fallback contract rather than pretending SVG was generated:
+
+```json
+{
+  "requestedFormat": "svg",
+  "actualFormat": "png",
+  "formatNotice": "SVG/vector output is not supported by generate_image. A raster PNG is generated instead."
+}
+```
+
 With GRS AI, the tool uses the Nano Banana API:
 
 - `POST https://grsaiapi.com/v1/draw/nano-banana`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.184",
+  "version": "0.20.185",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/references/agintiflow-npm-publication-memory.md

@@ -2,12 +2,24 @@
 
 Date: 2026-05-20
 
+Updated: 2026-05-31
+
 This note records the working publication route for AgInTiFlow so future release work does not get blocked by stale local npm tokens or repeated discussion about why direct `npm publish` failed.
 
 ## Published Evidence
 
 Latest verified release:
 
+- Version: `0.20.184`
+- Commit: `9b22f4c`
+- GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26700154894`
+- Workflow result: success
+- npm registry check: `npm view @lazyingart/agintiflow version dist-tags.latest --registry=https://registry.npmjs.org` returned `0.20.184`.
+- Installed verification: `npm install -g @lazyingart/agintiflow@0.20.184` then `aginti --version` returned `0.20.184`.
+- Webapp verification: `aginti webapp restart --port 3210` then `curl -fsS http://127.0.0.1:3210/health` returned `version":"0.20.184"` from the global npm package path.
+
+Previous verified release:
+
 - Version: `0.20.182`
 - Commit: `b5492f7`
 - GitHub Actions run: `https://github.com/lazyingart/AgInTiFlow/actions/runs/26198123298`

package/scripts/smoke-auxiliary-tools.js

@@ -60,6 +60,27 @@ try {
     }
   );
   assert(veniceDryRun.ok && veniceDryRun.provider === "venice", "venice generate_image dry run failed");
+  const svgFallbackDryRun = await generateImage(
+    {
+      provider: "venice",
+      prompt: "A simple geometric logo requested as SVG.",
+      outputDir: "artifacts/images/svg-fallback-dry-run",
+      outputStem: "logo.svg",
+      format: "svg",
+      dryRun: true,
+    },
+    {
+      commandCwd: workspace,
+      allowFileTools: true,
+    }
+  );
+  assert(svgFallbackDryRun.ok && svgFallbackDryRun.requestedFormat === "svg", "SVG fallback did not record requestedFormat");
+  assert(svgFallbackDryRun.actualFormat === "png", "SVG fallback did not select PNG output");
+  assert(/raster PNG/i.test(svgFallbackDryRun.formatNotice || ""), "SVG fallback did not explain the PNG fallback");
+  const svgFallbackManifest = JSON.parse(
+    await fs.readFile(path.join(workspace, "artifacts/images/svg-fallback-dry-run/task_manifest.json"), "utf8")
+  );
+  assert(svgFallbackManifest.requestedFormat === "svg" && svgFallbackManifest.actualFormat === "png", "SVG fallback manifest missing format contract");
 
   const blocked = await generateImage(
     {
@@ -109,6 +130,7 @@ try {
           "venice_image_skill_listed",
           "generate_image_dry_run",
           "venice_generate_image_dry_run",
+          "svg_request_png_fallback",
           "generate_image_guardrail",
           "mock_agent_image_tool",
         ],

package/scripts/smoke-web-api.js

@@ -178,6 +178,23 @@ try {
   }
   const traversalResponse = await fetch(`${baseUrl}/api/workspace/raw?commandCwd=${encodeURIComponent(runtimeDir)}&path=../escape.txt`);
   if (traversalResponse.ok) throw new Error("workspace raw endpoint allowed path traversal");
+  const imageApiDryRun = await fetchJson("/api/auxiliary/generate-image", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      commandCwd: runtimeDir,
+      provider: "venice",
+      prompt: "A compact logo requested as SVG for API fallback testing.",
+      format: "svg",
+      outputDir: "artifacts/images/api-svg-fallback",
+      outputStem: "api-logo.svg",
+      dryRun: true,
+    }),
+  });
+  if (!imageApiDryRun.ok || imageApiDryRun.requestedFormat !== "svg" || imageApiDryRun.actualFormat !== "png") {
+    throw new Error(`direct auxiliary image API did not return SVG-to-PNG fallback: ${JSON.stringify(imageApiDryRun)}`);
+  }
+  await fs.access(path.join(runtimeDir, "artifacts/images/api-svg-fallback/task_manifest.json"));
   if (config.preferences?.sandboxMode !== "docker-workspace") throw new Error("web did not default to docker workspace");
   if (config.preferences?.packageInstallPolicy !== "allow") throw new Error("web did not default to Docker package installs");
   if (config.preferences?.permissionMode !== "normal") throw new Error("web did not default to normal permission mode");
@@ -572,6 +589,7 @@ try {
           "POST /api/workspace/write",
           "POST /api/workspace/rename",
           "POST /api/workspace/delete",
+          "POST /api/auxiliary/generate-image",
           "/api/workspace/changes",
           "stale running status reconciliation",
           "/api/sessions/:id/artifacts",

package/src/agent-runner.js

@@ -629,7 +629,7 @@ async function createInitialState(config, sessionId) {
           config.allowAuxiliaryTools
             ? `Auxiliary skills are available: ${listAuxiliarySkills()
                 .map((skill) => `${skill.id} via ${skill.toolName} (${skill.available ? "key available" : `needs ${skill.keyName}`})`)
-                .join(", ")}. Use generate_image for real raster image/photo/illustration/cover/poster/logo requests when appropriate; if image keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.`
+                .join(", ")}. Use generate_image for real raster image/photo/illustration/cover/poster/logo requests when appropriate. generate_image is raster-only; if SVG/vector is requested, either create true SVG/LaTeX/HTML with file tools or call generate_image with format=png and explicitly report requestedFormat=svg, actualFormat=png. If image keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.`
             : "Auxiliary skills are disabled for this run.",
           config.allowWebSearch
             ? "web_search is available for lightweight snippets. web_research is available for sourced, persisted research artifacts; use domains for official-source constraints and mode=openai only when hosted OpenAI web research is needed and configured. Prefer these tools over browser search-engine navigation."

package/src/auxiliary-tools.js

@@ -10,6 +10,7 @@ const DEFAULT_IMAGE_MODEL = "nano-banana-2";
 const DEFAULT_VENICE_IMAGE_MODEL = "nano-banana-2";
 const DEFAULT_ASPECT_RATIO = "1:1";
 const DEFAULT_IMAGE_SIZE = "2K";
+const DEFAULT_OUTPUT_FORMAT = "png";
 const TRANSIENT_HTTP_CODES = new Set([408, 425, 429, 500, 502, 503, 504]);
 const MAX_PROMPT_BYTES = 120_000;
 const MAX_REFERENCE_BYTES = 4_000_000;
@@ -42,11 +43,45 @@ function timestampSlug() {
 function safeStem(value = "image") {
   const stem = String(value || "image")
     .trim()
+    .replace(/\.(?:svg|png|jpe?g|webp|gif)$/i, "")
     .replace(/[^A-Za-z0-9._-]+/g, "-")
     .replace(/^-+|-+$/g, "");
   return stem || "image";
 }
 
+function normalizeOutputFormat(args = {}) {
+  const requested = String(args.outputFormat || args.format || DEFAULT_OUTPUT_FORMAT)
+    .trim()
+    .toLowerCase()
+    .replace(/^image\//, "");
+  if (requested === "svg" || requested === "svg+xml" || requested === "vector") {
+    return {
+      requestedFormat: requested === "svg+xml" ? "svg" : requested,
+      actualFormat: "png",
+      notice: "SVG/vector output is not supported by generate_image. A raster PNG is generated instead.",
+    };
+  }
+  if (requested === "webp") {
+    return {
+      requestedFormat: "webp",
+      actualFormat: "webp",
+      notice: "",
+    };
+  }
+  if (["jpg", "jpeg", "gif"].includes(requested)) {
+    return {
+      requestedFormat: requested,
+      actualFormat: "png",
+      notice: `${requested.toUpperCase()} output is not currently exposed by generate_image. A raster PNG is generated instead.`,
+    };
+  }
+  return {
+    requestedFormat: requested || DEFAULT_OUTPUT_FORMAT,
+    actualFormat: DEFAULT_OUTPUT_FORMAT,
+    notice: "",
+  };
+}
+
 function normalizeAspectRatio(value) {
   const text = String(value || DEFAULT_ASPECT_RATIO).trim();
   return /^(?:\d+:\d+|1:1|2:3|3:2|3:4|4:3|9:16|16:9)$/.test(text) ? text : DEFAULT_ASPECT_RATIO;
@@ -305,7 +340,7 @@ function veniceBaseUrl(value = "") {
     .replace(/\/+$/, "");
 }
 
-async function generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, signal = null }) {
+async function generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, formatInfo, signal = null }) {
   const apiKey = veniceKey();
   if (!apiKey) {
     throw new Error("Missing VENICE_API_KEY. Run `aginti login venice` or `aginti keys set venice --stdin`.");
@@ -314,7 +349,7 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
   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 format = formatInfo.actualFormat === "webp" ? "webp" : "png";
   const sizing = veniceSizingForModel(model, args);
   const payload = {
     model,
@@ -356,6 +391,9 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
   manifest.provider = "venice";
   manifest.host = base;
   manifest.model = model;
+  manifest.requestedFormat = formatInfo.requestedFormat;
+  manifest.actualFormat = format;
+  if (formatInfo.notice) manifest.formatNotice = formatInfo.notice;
   manifest.status = "succeeded";
   manifest.finishedAt = new Date().toISOString();
   manifest.downloadedFiles = downloads;
@@ -372,7 +410,10 @@ async function generateVeniceImages({ prompt, args, target, outputStem, manifest
     promptPath: path.posix.join(target.relativePath, "prompt.txt"),
     requestPayloadPath: path.posix.join(target.relativePath, "request_payload.redacted.json"),
     taskId: resultPayload.id ? String(resultPayload.id) : "",
-    summary: `${imagePaths.length} image(s) generated through Venice`,
+    requestedFormat: formatInfo.requestedFormat,
+    actualFormat: format,
+    formatNotice: formatInfo.notice,
+    summary: `${imagePaths.length} image(s) generated through Venice${formatInfo.notice ? ` (${formatInfo.notice})` : ""}`,
   };
 }
 
@@ -403,6 +444,7 @@ export async function generateImage(args = {}, config = {}) {
   }
 
   const provider = args.provider ? normalizeImageProvider(args.provider) : defaultImageProvider(config);
+  const formatInfo = normalizeOutputFormat(args);
   const host = provider === "venice" ? veniceBaseUrl(args.host) : String(args.host || DEFAULT_GRS_HOST).trim().replace(/\/+$/, "") || DEFAULT_GRS_HOST;
   const model =
     provider === "venice"
@@ -419,6 +461,7 @@ export async function generateImage(args = {}, config = {}) {
     webHook: "-1",
     shutProgress: Boolean(args.shutProgress),
   };
+  if (provider === "venice") payload.format = formatInfo.actualFormat;
 
   const redactedPayload = redactPayload(payload);
   redactedPayload.urls = references.map((item) => item.redacted);
@@ -433,6 +476,9 @@ export async function generateImage(args = {}, config = {}) {
     provider,
     host,
     model,
+    requestedFormat: formatInfo.requestedFormat,
+    actualFormat: formatInfo.actualFormat,
+    formatNotice: formatInfo.notice,
     outputDir: target.relativePath,
     promptFile: path.posix.join(target.relativePath, "prompt.txt"),
     requestPayloadRedacted: path.posix.join(target.relativePath, "request_payload.redacted.json"),
@@ -452,12 +498,15 @@ export async function generateImage(args = {}, config = {}) {
       promptPath: path.posix.join(target.relativePath, "prompt.txt"),
       requestPayloadPath: path.posix.join(target.relativePath, "request_payload.redacted.json"),
       imagePaths: [],
-      summary: "Prepared redacted image-generation payload without calling the provider.",
+      requestedFormat: formatInfo.requestedFormat,
+      actualFormat: formatInfo.actualFormat,
+      formatNotice: formatInfo.notice,
+      summary: `Prepared redacted image-generation payload without calling the provider.${formatInfo.notice ? ` ${formatInfo.notice}` : ""}`,
     };
   }
 
   if (provider === "venice") {
-    return generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, signal: config.abortSignal });
+    return generateVeniceImages({ prompt, args, target, outputStem, manifest, manifestPath, formatInfo, signal: config.abortSignal });
   }
 
   const apiKey = grsaiKey();
@@ -515,6 +564,9 @@ export async function generateImage(args = {}, config = {}) {
   }
 
   manifest.status = "succeeded";
+  manifest.requestedFormat = formatInfo.requestedFormat;
+  manifest.actualFormat = path.extname(imagePaths[0] || "").replace(/^\./, "") || formatInfo.actualFormat;
+  if (formatInfo.notice) manifest.formatNotice = formatInfo.notice;
   manifest.finishedAt = new Date().toISOString();
   manifest.downloadedFiles = downloads;
   await writeJson(manifestPath, manifest);
@@ -528,6 +580,9 @@ export async function generateImage(args = {}, config = {}) {
     promptPath: path.posix.join(target.relativePath, "prompt.txt"),
     requestPayloadPath: path.posix.join(target.relativePath, "request_payload.redacted.json"),
     taskId: String(taskId),
-    summary: `${imagePaths.length} image(s) generated`,
+    requestedFormat: formatInfo.requestedFormat,
+    actualFormat: manifest.actualFormat,
+    formatNotice: formatInfo.notice,
+    summary: `${imagePaths.length} image(s) generated${formatInfo.notice ? ` (${formatInfo.notice})` : ""}`,
   };
 }

package/src/model-client.js

@@ -723,7 +723,7 @@ export async function createPlan(client, config, state) {
           config.allowAuxiliaryTools
             ? `Auxiliary skills are enabled: ${listAuxiliarySkills()
                 .map((skill) => `${skill.id} via ${skill.toolName} (${skill.available ? "key available" : `needs ${skill.keyName}`})`)
-                .join(", ")}. For raster image generation requests, plan to use generate_image when a GRSAI or Venice image key is available; otherwise ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.`
+                .join(", ")}. For raster image generation requests, plan to use generate_image when a GRSAI or Venice image key is available. generate_image is raster-only; if SVG/vector is requested, either create true SVG/LaTeX/HTML with file tools or use PNG fallback and report requestedFormat=svg, actualFormat=png. Otherwise ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.`
             : "Auxiliary skills are disabled for this run.",
           config.allowWebSearch
             ? "web_search is available for lightweight snippets. web_research is available for auditable sourced research with persisted artifacts; use mode=snippets by default and mode=openai only when hosted OpenAI web research is needed and configured. Prefer these tools over opening a search engine in the browser."
@@ -1578,7 +1578,7 @@ export async function requestNextStep(client, config, messages) {
       function: {
         name: "generate_image",
         description:
-          "Generate a raster image artifact through optional GRS AI Nano Banana or Venice image-generation skills. Use for user requests that explicitly need a real image/photo/illustration/cover/poster/logo concept rather than SVG/code-native graphics. Saves prompt, redacted payload, manifest, and downloaded images in the workspace. If keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.",
+          "Generate a raster image artifact through optional GRS AI Nano Banana or Venice image-generation skills. Use for user requests that explicitly need a real image/photo/illustration/cover/poster/logo concept rather than SVG/code-native graphics. If a caller requests SVG/vector through this tool, request PNG and report the SVG-to-PNG fallback; if true vector is required, write SVG/LaTeX/HTML deterministically with file tools instead. Saves prompt, redacted payload, manifest, and downloaded images in the workspace. If keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.",
         parameters: {
           type: "object",
           properties: {
@@ -1590,6 +1590,11 @@ export async function requestNextStep(client, config, messages) {
             prompt: { type: "string", description: "Detailed image-generation prompt." },
             outputDir: { type: "string", description: "Workspace-relative output directory. Defaults to artifacts/images/<timestamp>." },
             outputStem: { type: "string", description: "Filename stem for downloaded images." },
+            format: {
+              type: "string",
+              enum: ["png", "webp", "svg", "jpeg", "jpg", "gif"],
+              description: "Requested output format. SVG/vector is not supported by generate_image and is returned as a PNG fallback with requestedFormat/actualFormat metadata.",
+            },
             aspectRatio: { type: "string", description: "Aspect ratio such as 1:1, 16:9, 2:3, or 3:2." },
             imageSize: { type: "string", description: "Image size such as 1K, 2K, or 4K." },
             model: { type: "string", description: "Image model. Defaults to nano-banana-2; Venice also supports models such as gpt-image-2, wan-2-7-text-to-image, qwen-image-2, and bria-bg-remover." },

package/src/task-profiles.js

@@ -248,7 +248,7 @@ export const TASK_PROFILES = {
     id: "image",
     label: "Image generation",
     prompt:
-      "For raster image, cover, poster, illustration, photo, and logo-concept tasks, write a clear visual prompt, use generate_image when the optional GRS AI or Venice image key is available, save outputs under artifacts/images, and send the selected image to the canvas. If keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.",
+      "For raster image, cover, poster, illustration, photo, and logo-concept tasks, write a clear visual prompt, use generate_image when the optional GRS AI or Venice image key is available, save outputs under artifacts/images, and send the selected image to the canvas. generate_image is raster-only: if SVG/vector is requested, either create deterministic SVG/LaTeX/HTML with file tools or return a PNG fallback with requestedFormat=svg and actualFormat=png. If keys are missing, ask the user to run /auxiliary grsai, aginti login grsai, or aginti login venice.",
     tools: ["auxiliary:image_generation", "files", "canvas"],
   },
   aaps: {

package/web.js

@@ -39,6 +39,7 @@ import {
   setProviderKey,
 } from "./src/project.js";
 import { buildCapabilityReport } from "./src/capabilities.js";
+import { generateImage } from "./src/auxiliary-tools.js";
 import { listExternalSkillPacks, listSkills } from "./src/skill-library.js";
 import { platformInfo, platformLabel, platformSetupHints } from "./src/platform.js";
 import { normalizeLanguage } from "./src/i18n.js";
@@ -1585,6 +1586,28 @@ app.post("/api/mcp", async (req, res) => {
   }
 });
 
+app.post("/api/auxiliary/generate-image", async (req, res) => {
+  try {
+    const body = req.body || {};
+    const preferences = normalizePreferencePayload({}, db.getPreferences());
+    const config = buildRunConfig({
+      ...preferences,
+      ...body,
+      goal: "auxiliary image generation",
+      commandCwd: body.commandCwd || body.cwd || preferences.commandCwd || baseDir,
+      allowFileTools: true,
+      allowAuxiliaryTools: true,
+      auxiliaryProvider: body.provider || body.auxiliaryProvider || preferences.auxiliaryProvider,
+      auxiliaryModel: body.model || body.auxiliaryModel || preferences.auxiliaryModel,
+    });
+    const result = await generateImage(body, config);
+    const status = result.ok ? 200 : result.blocked ? 403 : 400;
+    res.status(status).json(result);
+  } catch (error) {
+    res.status(400).json({ ok: false, toolName: "generate_image", error: error instanceof Error ? error.message : String(error) });
+  }
+});
+
 app.post("/api/keys/:provider", async (req, res) => {
   try {
     const result = await setProviderKey(baseDir, req.params.provider, req.body?.apiKey || req.body?.key || "");