@lazyingart/agintiflow 0.8.12 → 0.9.0

package/src/auxiliary-tools.js

@@ -0,0 +1,344 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { redactSensitiveText } from "./redaction.js";
+import { checkWorkspaceToolUse, resolveWorkspacePath } from "./workspace-tools.js";
+
+const DEFAULT_GRS_HOST = "https://grsaiapi.com";
+const DEFAULT_IMAGE_MODEL = "nano-banana-2";
+const DEFAULT_ASPECT_RATIO = "1:1";
+const DEFAULT_IMAGE_SIZE = "2K";
+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;
+
+export const AUXILIARY_SKILLS = [
+  {
+    id: "image_generation",
+    label: "Image generation",
+    provider: "grsai",
+    keyName: "GRSAI",
+    toolName: "generate_image",
+    description:
+      "Generate raster image artifacts through GRS AI Nano Banana, save the manifest and image files in the workspace, then send selected results to the canvas.",
+  },
+];
+
+function timestampSlug() {
+  return new Date().toISOString().replace(/[:.]/g, "-");
+}
+
+function safeStem(value = "image") {
+  const stem = String(value || "image")
+    .trim()
+    .replace(/[^A-Za-z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return stem || "image";
+}
+
+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;
+}
+
+function normalizeImageSize(value) {
+  const text = String(value || DEFAULT_IMAGE_SIZE).trim();
+  return /^(?:1K|2K|4K|1024x1024|1024x1536|1536x1024)$/i.test(text) ? text : DEFAULT_IMAGE_SIZE;
+}
+
+function hashBuffer(buffer) {
+  return crypto.createHash("sha256").update(buffer).digest("hex");
+}
+
+function mimeFromPath(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === ".jpg" || ext === ".jpeg") return "image/jpeg";
+  if (ext === ".webp") return "image/webp";
+  if (ext === ".gif") return "image/gif";
+  if (ext === ".svg") return "image/svg+xml";
+  return "image/png";
+}
+
+function parseJsonResponse(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed;
+  } catch {
+    // Some providers stream server-sent JSON chunks; fall through to line parsing.
+  }
+
+  let lastObject = null;
+  for (const line of String(raw || "").split(/\r?\n/)) {
+    const chunk = line.trim().replace(/^data:\s*/, "");
+    if (!chunk) continue;
+    try {
+      const parsed = JSON.parse(chunk);
+      if (parsed && typeof parsed === "object") lastObject = parsed;
+    } catch {
+      // Ignore non-JSON progress lines.
+    }
+  }
+  if (!lastObject) throw new Error("Failed to parse image API response as JSON.");
+  return lastObject;
+}
+
+function redactPayload(payload) {
+  const copy = { ...payload };
+  copy.urls = (copy.urls || []).map((item) => {
+    const text = String(item || "");
+    if (text.startsWith("data:")) return `<data-uri length=${text.length}>`;
+    return redactSensitiveText(text);
+  });
+  return copy;
+}
+
+function grsaiKey() {
+  return String(process.env.GRSAI || process.env.GRSAI_API_KEY || "").trim();
+}
+
+export function listAuxiliarySkills() {
+  return AUXILIARY_SKILLS.map((skill) => ({
+    ...skill,
+    available: skill.provider === "grsai" ? Boolean(grsaiKey()) : false,
+  }));
+}
+
+async function referenceToUrl(item, config) {
+  const value = String(item || "").trim();
+  if (!value) return { url: "", redacted: "" };
+  if (/^https?:\/\//i.test(value)) return { url: value, redacted: value };
+  if (value.startsWith("data:")) return { url: value, redacted: `<data-uri length=${value.length}>` };
+
+  const target = resolveWorkspacePath(config, value);
+  const stat = await fs.stat(target.absolutePath);
+  if (!stat.isFile()) throw new Error(`Reference image is not a file: ${target.relativePath}`);
+  if (stat.size > MAX_REFERENCE_BYTES) throw new Error(`Reference image is too large: ${target.relativePath}`);
+  const buffer = await fs.readFile(target.absolutePath);
+  return {
+    url: `data:${mimeFromPath(target.relativePath)};base64,${buffer.toString("base64")}`,
+    redacted: `<${target.relativePath} data-uri bytes=${buffer.length}>`,
+  };
+}
+
+async function writeJson(filePath, payload) {
+  await fs.writeFile(filePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+async function requestJson(url, payload, apiKey, { timeoutMs = 300000, retries = 2 } = {}) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+      const text = await response.text();
+      if (!response.ok) {
+        const error = new Error(`Image API HTTP ${response.status}: ${redactSensitiveText(text).slice(0, 600)}`);
+        error.status = response.status;
+        throw error;
+      }
+      return parseJsonResponse(text);
+    } catch (error) {
+      lastError = error;
+      const retryable = TRANSIENT_HTTP_CODES.has(Number(error?.status)) || /aborted|timeout|fetch failed/i.test(String(error?.message || ""));
+      if (!retryable || attempt >= retries) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 2000 + attempt * 2000));
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  throw lastError || new Error("Image API request failed.");
+}
+
+async function pollResult({ host, taskId, apiKey, outputDir, intervalMs = 5000, timeoutMs = 900000, requestTimeoutMs = 300000 }) {
+  const started = Date.now();
+  const pollUrl = `${host.replace(/\/+$/, "")}/v1/draw/result`;
+  let attempt = 0;
+  while (true) {
+    const result = await requestJson(pollUrl, { id: taskId }, apiKey, {
+      timeoutMs: requestTimeoutMs,
+      retries: 4,
+    });
+    await writeJson(path.join(outputDir, "result_response.json"), result);
+
+    const data = result.data || {};
+    const status = result.status || data.status;
+    if (status === "succeeded" || status === "failed") return result;
+    if (Date.now() - started > timeoutMs) throw new Error(`Image generation polling timed out for task ${taskId}.`);
+    attempt += 1;
+    await new Promise((resolve) => setTimeout(resolve, Math.min(intervalMs + attempt * 250, 12000)));
+  }
+}
+
+async function downloadImage(url, destination) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "AgInTiFlow/1.0",
+    },
+  });
+  if (!response.ok) throw new Error(`Image download failed with HTTP ${response.status}.`);
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await fs.writeFile(destination, buffer);
+  return {
+    bytes: buffer.length,
+    sha256: hashBuffer(buffer),
+  };
+}
+
+function resultUrls(payload) {
+  const data = payload.data || payload;
+  const results = Array.isArray(data.results) ? data.results : [];
+  return results.map((item) => item?.url).filter(Boolean);
+}
+
+export async function generateImage(args = {}, config = {}) {
+  const prompt = String(args.prompt || "").trim();
+  if (!prompt) throw new Error("Image prompt is required.");
+  if (Buffer.byteLength(prompt, "utf8") > MAX_PROMPT_BYTES) throw new Error("Image prompt is too large.");
+
+  const outputDirInput = args.outputDir || `artifacts/images/${timestampSlug()}`;
+  const target = resolveWorkspacePath(config, outputDirInput);
+  const writePolicy = checkWorkspaceToolUse("write_file", { path: path.join(target.relativePath, "task_manifest.json") }, config);
+  if (!writePolicy.allowed) {
+    return {
+      ok: false,
+      blocked: true,
+      reason: writePolicy.reason,
+      category: writePolicy.category,
+      toolName: "generate_image",
+    };
+  }
+
+  await fs.mkdir(target.absolutePath, { recursive: true });
+  const referenceInputs = Array.isArray(args.referenceImages) ? args.referenceImages : [];
+  const references = [];
+  for (const item of referenceInputs) {
+    const converted = await referenceToUrl(item, config);
+    if (converted.url) references.push(converted);
+  }
+
+  const host = String(args.host || DEFAULT_GRS_HOST).trim().replace(/\/+$/, "") || DEFAULT_GRS_HOST;
+  const model = String(args.model || DEFAULT_IMAGE_MODEL).trim() || DEFAULT_IMAGE_MODEL;
+  const outputStem = safeStem(args.outputStem || "image");
+  const payload = {
+    model,
+    prompt,
+    urls: references.map((item) => item.url),
+    aspectRatio: normalizeAspectRatio(args.aspectRatio),
+    imageSize: normalizeImageSize(args.imageSize),
+    webHook: "-1",
+    shutProgress: Boolean(args.shutProgress),
+  };
+
+  const redactedPayload = redactPayload(payload);
+  redactedPayload.urls = references.map((item) => item.redacted);
+  const promptPath = path.join(target.absolutePath, "prompt.txt");
+  const requestPath = path.join(target.absolutePath, "request_payload.redacted.json");
+  const manifestPath = path.join(target.absolutePath, "task_manifest.json");
+  await fs.writeFile(promptPath, `${prompt}\n`, "utf8");
+  await writeJson(requestPath, redactedPayload);
+
+  const manifest = {
+    tool: "generate_image",
+    provider: "grsai",
+    host,
+    model,
+    outputDir: target.relativePath,
+    promptFile: path.posix.join(target.relativePath, "prompt.txt"),
+    requestPayloadRedacted: path.posix.join(target.relativePath, "request_payload.redacted.json"),
+    status: args.dryRun ? "prepared" : "started",
+    createdAt: new Date().toISOString(),
+  };
+  await writeJson(manifestPath, manifest);
+
+  if (args.dryRun) {
+    return {
+      ok: true,
+      dryRun: true,
+      toolName: "generate_image",
+      path: target.relativePath,
+      manifestPath: path.posix.join(target.relativePath, "task_manifest.json"),
+      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.",
+    };
+  }
+
+  const apiKey = grsaiKey();
+  if (!apiKey) {
+    throw new Error("Missing GRSAI key. Run `aginti login grsai`, `aginti keys set grsai --stdin`, or `/auxilliary grsai`.");
+  }
+
+  const submitUrl = `${host}/v1/draw/nano-banana`;
+  const submitPayload = await requestJson(submitUrl, payload, apiKey, {
+    timeoutMs: Number(args.requestTimeoutMs) || 300000,
+    retries: 2,
+  });
+  await writeJson(path.join(target.absolutePath, "submit_response.json"), submitPayload);
+  const taskId = submitPayload?.data?.id || submitPayload?.id;
+  if (!taskId) throw new Error("Image API did not return a task id.");
+
+  manifest.taskId = String(taskId);
+  manifest.status = "submitted";
+  manifest.submittedAt = new Date().toISOString();
+  await writeJson(manifestPath, manifest);
+
+  const resultPayload = await pollResult({
+    host,
+    taskId: String(taskId),
+    apiKey,
+    outputDir: target.absolutePath,
+    intervalMs: Number(args.pollIntervalMs) || 5000,
+    timeoutMs: Number(args.pollTimeoutMs) || 900000,
+    requestTimeoutMs: Number(args.requestTimeoutMs) || 300000,
+  });
+
+  const status = resultPayload.status || resultPayload?.data?.status;
+  if (status !== "succeeded") {
+    manifest.status = status || "failed";
+    manifest.finishedAt = new Date().toISOString();
+    await writeJson(manifestPath, manifest);
+    throw new Error(`Image generation failed with status ${status || "unknown"}. See ${manifestPath}.`);
+  }
+
+  const urls = resultUrls(resultPayload);
+  if (urls.length === 0) throw new Error("Image API succeeded but returned no image URLs.");
+  const imagePaths = [];
+  const downloads = [];
+  for (let index = 0; index < urls.length; index += 1) {
+    const parsed = new URL(urls[index]);
+    const suffix = path.extname(parsed.pathname) || ".png";
+    const filename = urls.length === 1 ? `${outputStem}${suffix}` : `${outputStem}_${String(index + 1).padStart(2, "0")}${suffix}`;
+    const absolutePath = path.join(target.absolutePath, filename);
+    const info = await downloadImage(urls[index], absolutePath);
+    const relativePath = path.posix.join(target.relativePath, filename);
+    imagePaths.push(relativePath);
+    downloads.push({ path: relativePath, ...info });
+  }
+
+  manifest.status = "succeeded";
+  manifest.finishedAt = new Date().toISOString();
+  manifest.downloadedFiles = downloads;
+  await writeJson(manifestPath, manifest);
+
+  return {
+    ok: true,
+    toolName: "generate_image",
+    path: imagePaths[0] || target.relativePath,
+    imagePaths,
+    manifestPath: path.posix.join(target.relativePath, "task_manifest.json"),
+    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`,
+  };
+}

package/src/capabilities.js

@@ -7,6 +7,7 @@ import { getModelPresets } from "./model-routing.js";
 import { listProjectSessions, projectPaths, providerKeyStatus } from "./project.js";
 import { listTaskProfiles } from "./task-profiles.js";
 import { listAgentWrappers } from "./tool-wrappers.js";
+import { listAuxiliarySkills } from "./auxiliary-tools.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -139,6 +140,10 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
     capability("docker", Boolean(dockerStatus?.dockerAvailable), dockerStatus || {}),
     capability("deepseek-key", keyStatus.deepseek, { envVars: keyStatus.envVars.deepseek }),
     capability("openai-key", keyStatus.openai, { envVars: keyStatus.envVars.openai }),
+    capability("grsai-key", keyStatus.grsai, {
+      envVars: keyStatus.envVars.grsai,
+      setup: "Optional for image generation. Run `aginti login grsai` or use `/auxilliary grsai` in chat.",
+    }),
     capability("file-tools", Boolean(config.allowFileTools), { workspace: config.commandCwd }),
     capability("shell-tool", Boolean(config.allowShellTool), {
       sandboxMode: config.sandboxMode,
@@ -178,6 +183,7 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
     keys: {
       deepseek: keyStatus.deepseek,
       openai: keyStatus.openai,
+      grsai: keyStatus.grsai,
       mock: true,
       localEnv: keyStatus.localEnv,
       envVars: keyStatus.envVars,
@@ -194,6 +200,13 @@ export async function buildCapabilityReport(projectRoot, packageVersion, config)
         label: profile.label,
         tools: profile.tools,
       })),
+      auxiliarySkills: listAuxiliarySkills().map((skill) => ({
+        id: skill.id,
+        label: skill.label,
+        provider: skill.provider,
+        toolName: skill.toolName,
+        available: skill.available,
+      })),
     },
     checks,
     maintenancePolicy: maintenancePolicyChecks(config),
@@ -221,7 +234,7 @@ export function printCapabilityReport(report) {
   console.log(
     `keys: deepseek=${report.keys.deepseek ? "available" : "missing"} openai=${
       report.keys.openai ? "available" : "missing"
-    } mock=available localEnv=${report.keys.localEnv}`
+    } grsai=${report.keys.grsai ? "available" : "missing"} mock=available localEnv=${report.keys.localEnv}`
   );
   for (const check of report.checks) {
     const suffix = check.version ? ` ${check.version}` : check.reason ? ` ${check.reason}` : check.hint ? ` ${check.hint}` : "";

package/src/cli.js

@@ -44,6 +44,7 @@ export function parseArgs(argv) {
     allowShellTool: undefined,
     allowFileTools: undefined,
     allowWrapperTools: undefined,
+    allowAuxiliaryTools: undefined,
     allowDestructive: undefined,
     preferredWrapper: "",
     taskProfile: "",
@@ -60,6 +61,7 @@ export function parseArgs(argv) {
     host: "",
     listProfiles: false,
     latex: false,
+    image: false,
   };
 
   const parts = [];
@@ -141,6 +143,12 @@ export function parseArgs(argv) {
       result.maxSteps = result.maxSteps || 30;
       continue;
     }
+    if (arg === "--image" || arg === "--image-gen" || arg === "--image-generation") {
+      result.image = true;
+      result.taskProfile = "image";
+      result.allowAuxiliaryTools = true;
+      continue;
+    }
     if (arg === "--max-steps") {
       result.maxSteps = Number(readOption(argv, i));
       i += 1;
@@ -166,6 +174,14 @@ export function parseArgs(argv) {
       result.allowFileTools = false;
       continue;
     }
+    if (arg === "--allow-auxiliary-tools" || arg === "--allow-auxiliary") {
+      result.allowAuxiliaryTools = true;
+      continue;
+    }
+    if (arg === "--no-auxiliary-tools" || arg === "--no-auxiliary") {
+      result.allowAuxiliaryTools = false;
+      continue;
+    }
     if (arg === "--allow-wrappers") {
       result.allowWrapperTools = true;
       continue;
@@ -220,15 +236,23 @@ export function parseArgs(argv) {
 
 function printUsage() {
   console.log(
-    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
+    'Usage: aginti [chat] OR aginti web [--port 3210] OR aginti login deepseek|openai|grsai OR aginti resume [latest|<session-id>] ["prompt"] OR aginti queue <session-id> "message" OR aginti [--image] [--latex] [--routing smart|fast|complex|manual] [--provider deepseek|openai|mock] [--sandbox-mode host|docker-readonly|docker-workspace] [--package-install-policy block|prompt|allow] [--approve-package-installs] [--allow-shell|--no-shell] [--allow-destructive] [--allow-file-tools|--no-file-tools] [--allow-auxiliary-tools|--no-auxiliary-tools] [--allow-wrappers --wrapper codex] [--sandbox-status|--sandbox-preflight] "your task"'
   );
 }
 
+function providerLabel(provider) {
+  const normalized = String(provider || "").toLowerCase();
+  if (normalized === "openai") return "OpenAI";
+  if (normalized === "grsai" || normalized === "auxiliary" || normalized === "auxilliary") return "GRSAI";
+  return "DeepSeek";
+}
+
 function agentDefaults(args) {
   const defaults = {
     ...args,
     allowShellTool: args.allowShellTool ?? true,
     allowFileTools: args.allowFileTools ?? true,
+    allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
     sandboxMode: args.sandboxMode || "docker-workspace",
     packageInstallPolicy: args.packageInstallPolicy || "allow",
     useDockerSandbox: args.useDockerSandbox ?? true,
@@ -279,7 +303,7 @@ function printDoctorReport(report) {
   console.log(
     `keys: deepseek=${report.keys.deepseek ? "available" : "missing"} openai=${
       report.keys.openai ? "available" : "missing"
-    } mock=available localEnv=${report.project.localEnvPresent}`
+    } grsai=${report.keys.grsai ? "available" : "missing"} mock=available localEnv=${report.project.localEnvPresent}`
   );
   console.log(
     `sandbox=${report.sandbox?.sandboxMode || "unknown"} docker=${
@@ -321,15 +345,15 @@ async function handleKeyCommand(argv) {
     console.log(
       `keys: deepseek=${status.deepseek ? "available" : "missing"} openai=${
         status.openai ? "available" : "missing"
-      } mock=available localEnv=${status.localEnv}`
+      } grsai=${status.grsai ? "available" : "missing"} mock=available localEnv=${status.localEnv}`
     );
-    console.log("env vars: DeepSeek=DEEPSEEK_API_KEY or LLM_API_KEY; OpenAI=OPENAI_API_KEY or LLM_API_KEY");
+    console.log("env vars: DeepSeek=DEEPSEEK_API_KEY or LLM_API_KEY; OpenAI=OPENAI_API_KEY or LLM_API_KEY; image=GRSAI or GRSAI_API_KEY");
     return;
   }
 
   if (verb === "set") {
     const target = provider || "deepseek";
-    const key = argv.includes("--stdin") ? await readStdin() : await promptHidden(`${target === "openai" ? "OpenAI" : "DeepSeek"} API key: `);
+    const key = argv.includes("--stdin") ? await readStdin() : await promptHidden(`${providerLabel(target)} API key/token: `);
     if (!key) {
       console.error("No key saved.");
       process.exit(1);
@@ -339,7 +363,7 @@ async function handleKeyCommand(argv) {
     return;
   }
 
-  console.error("Usage: aginti keys status OR aginti keys set deepseek [--stdin]");
+  console.error("Usage: aginti keys status OR aginti keys set deepseek|openai|grsai [--stdin]");
   process.exit(1);
 }
 
@@ -460,7 +484,7 @@ export async function main(argv = process.argv.slice(2)) {
     const provider = argv[1] || "deepseek";
     const key = argv.includes("--stdin") || !process.stdin.isTTY
       ? await readStdin()
-      : await promptHidden(`${provider === "openai" ? "OpenAI" : "DeepSeek"} API key: `);
+      : await promptHidden(`${providerLabel(provider)} API key/token: `);
     if (!key) {
       console.error("No key saved.");
       process.exit(1);

package/src/config.js

@@ -78,6 +78,10 @@ export function resolveRuntimeConfig(args, overrides = {}) {
       overrides.allowWrapperTools ?? args.allowWrapperTools ?? process.env.ALLOW_WRAPPER_TOOLS,
       false
     ),
+    allowAuxiliaryTools: parseBoolean(
+      overrides.allowAuxiliaryTools ?? args.allowAuxiliaryTools ?? process.env.ALLOW_AUXILIARY_TOOLS,
+      true
+    ),
     preferredWrapper: normalizeWrapperName(
       overrides.preferredWrapper ?? args.preferredWrapper ?? process.env.PREFERRED_WRAPPER ?? process.env.AGENT_WRAPPER
     ),

package/src/guardrails.js

@@ -151,6 +151,21 @@ export function checkToolUse({ toolName, args, snapshot, config }) {
     return { allowed: true };
   }
 
+  if (toolName === "generate_image") {
+    if (!config.allowAuxiliaryTools) {
+      return { allowed: false, reason: "Auxiliary tools are disabled for this run.", category: "auxiliary-tools" };
+    }
+
+    const prompt = String(args.prompt || "").trim();
+    if (!prompt) return { allowed: false, reason: "Image prompt is required.", category: "auxiliary-tools" };
+    if (Buffer.byteLength(prompt, "utf8") > MAX_CANVAS_CONTENT_BYTES) {
+      return { allowed: false, reason: "Image prompt is too large.", category: "auxiliary-tools" };
+    }
+
+    const outputDir = String(args.outputDir || "artifacts/images/generated").trim();
+    return checkWorkspaceToolUse("write_file", { path: `${outputDir.replace(/\/+$/, "")}/task_manifest.json` }, config);
+  }
+
   if (toolName === "send_to_canvas") {
     const title = String(args.title || "").trim();
     if (!title) return { allowed: false, reason: "Canvas title is required." };

package/src/interactive-cli.js

@@ -30,6 +30,8 @@ const SLASH_COMMANDS = [
   "/status",
   "/login",
   "/auth",
+  "/auxilliary",
+  "/auxiliary",
   "/new",
   "/resume",
   "/sessions",
@@ -206,8 +208,10 @@ function printHelp() {
       "Commands:",
       "  /help                     Show this help.",
       "  /status                   Show active route, workspace, sandbox, and session.",
-      "  /login [deepseek|openai]  Paste and save a project-local API key.",
-      "  /auth [deepseek|openai]   Alias for /login.",
+      "  /login [deepseek|openai|grsai]  Paste and save a project-local API key.",
+      "  /auth [deepseek|openai|grsai]   Alias for /login.",
+      "  /auxilliary [status|grsai|on|off|image]",
+      "                            Manage optional auxiliary skills, including GRS AI image generation.",
       "  /new                      Start a fresh session on the next message.",
       "  /resume <session-id>      Continue a saved session.",
       "  /sessions                 List recent sessions in this project.",
@@ -345,7 +349,7 @@ function printStatus(state) {
   printSystemLine(`provider=${state.provider || "auto"} routing=${state.routingMode} model=${state.model || "auto"}`);
   printSystemLine(`profile=${state.taskProfile} maxSteps=${state.maxSteps}`);
   printSystemLine(
-    `shell=${state.allowShellTool} files=${state.allowFileTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
+    `shell=${state.allowShellTool} files=${state.allowFileTools} auxiliary=${state.allowAuxiliaryTools} sandbox=${state.sandboxMode} installs=${state.packageInstallPolicy}`
   );
   if (state.sandboxMode !== "host") {
     printSystemLine(`dockerWorkspace=/workspace -> ${state.commandCwd || process.cwd()}`);
@@ -429,6 +433,7 @@ function createState(args = {}) {
     packageInstallPolicy: normalizePackageInstallPolicy(args.packageInstallPolicy || "allow"),
     allowShellTool: args.allowShellTool ?? true,
     allowFileTools: args.allowFileTools ?? true,
+    allowAuxiliaryTools: args.allowAuxiliaryTools ?? true,
     allowWrapperTools: args.allowWrapperTools ?? false,
     allowDestructive: args.allowDestructive ?? false,
     preferredWrapper: args.preferredWrapper || "codex",
@@ -463,23 +468,27 @@ async function maybeOnboardDeepSeekKey(state) {
 }
 
 async function promptAndSaveProviderKey(provider = "deepseek", state = null) {
-  const normalized = ["openai", "deepseek"].includes(String(provider || "").toLowerCase())
+  const aliases = { auxiliary: "grsai", auxilliary: "grsai", image: "grsai", imagegen: "grsai" };
+  const candidate = aliases[String(provider || "").toLowerCase()] || String(provider || "").toLowerCase();
+  const normalized = ["openai", "deepseek", "grsai"].includes(candidate)
     ? String(provider || "").toLowerCase()
     : "deepseek";
-  const labelText = normalized === "openai" ? "OpenAI" : "DeepSeek";
+  const canonical = aliases[normalized] || normalized;
+  const labelText = canonical === "openai" ? "OpenAI" : canonical === "grsai" ? "GRSAI" : "DeepSeek";
   const key = await promptHidden(`${labelText} API key/token (paste, Enter to save): `);
   if (!key) {
     printAgentMessage("No key saved.");
     return;
   }
 
-  const result = await setProviderKey(process.cwd(), normalized, key);
+  const result = await setProviderKey(process.cwd(), canonical, key);
   if (state) {
-    state.provider = normalized;
+    if (canonical !== "grsai") state.provider = canonical;
     if (state.routingMode === "manual" && state.model === "mock-agent") {
       state.routingMode = "smart";
       state.model = "";
     }
+    if (canonical === "grsai") state.allowAuxiliaryTools = true;
   }
   printAgentMessage(`Saved ${result.keyName} to project-local ignored env. Raw key was not printed.`);
 }
@@ -496,13 +505,53 @@ async function handleCommand(line, state, packageDir) {
   if (command === "status") {
     printStatus(state);
     const keys = providerKeyStatus(process.cwd());
-    printSystemLine(`keys deepseek=${keys.deepseek ? "available" : "missing"} openai=${keys.openai ? "available" : "missing"}`);
+    printSystemLine(
+      `keys deepseek=${keys.deepseek ? "available" : "missing"} openai=${keys.openai ? "available" : "missing"} grsai=${
+        keys.grsai ? "available" : "missing"
+      }`
+    );
     return true;
   }
   if (command === "login" || command === "auth") {
     await promptAndSaveProviderKey(value || "deepseek", state);
     return true;
   }
+  if (command === "auxilliary" || command === "auxiliary") {
+    const action = value || "status";
+    if (action === "status") {
+      const keys = providerKeyStatus(process.cwd());
+      printAgentMessage(
+        [
+          `Auxiliary tools: ${state.allowAuxiliaryTools ? "on" : "off"}`,
+          `Image generation: ${keys.grsai ? "GRSAI key available" : "missing GRSAI key"}`,
+          "Use `/auxilliary grsai` to paste the image key, `/auxilliary image` to switch to the image profile, or `/auxilliary off` to hide auxiliary tools.",
+        ].join("\n")
+      );
+      return true;
+    }
+    if (action === "on") {
+      state.allowAuxiliaryTools = true;
+      printSystemLine("auxiliary=on");
+      return true;
+    }
+    if (action === "off") {
+      state.allowAuxiliaryTools = false;
+      printSystemLine("auxiliary=off");
+      return true;
+    }
+    if (action === "image") {
+      state.allowAuxiliaryTools = true;
+      state.taskProfile = "image";
+      printSystemLine("auxiliary=on profile=image");
+      return true;
+    }
+    if (["grsai", "login", "key", "token"].includes(action)) {
+      await promptAndSaveProviderKey("grsai", state);
+      return true;
+    }
+    printAgentMessage("Usage: /auxilliary [status|grsai|on|off|image]");
+    return true;
+  }
   if (command === "new") {
     state.sessionId = "";
     printAgentMessage("Next message will start a new session.");
@@ -630,6 +679,7 @@ async function runPrompt(prompt, state, packageDir) {
       packageInstallPolicy: state.packageInstallPolicy,
       allowShellTool: state.allowShellTool,
       allowFileTools: state.allowFileTools,
+      allowAuxiliaryTools: state.allowAuxiliaryTools,
       allowWrapperTools: state.allowWrapperTools,
       allowDestructive: state.allowDestructive,
       preferredWrapper: state.preferredWrapper,