@rubytech/taskmaster 1.0.98 → 1.0.100

package/README.md

@@ -22,7 +22,7 @@ taskmaster provision
 Or one command on a fresh device:
 
 ```bash
-curl -fsSL https://taskmaster.bot/install.sh | bash
+curl -fsSL https://taskmaster.bot/install.sh | sudo bash
 ```
 
 After install, open the setup wizard in your browser:

package/dist/agents/system-prompt.js

@@ -8,10 +8,11 @@ function buildSkillsSection(params) {
         return [];
     return [
         "## Skills (mandatory)",
-        "Before replying: scan <available_skills> <description> entries.",
+        "Before taking any action (including tool calls): scan <available_skills> <description> entries.",
         `- If exactly one skill clearly applies: read its SKILL.md at <location> with \`${params.readToolName}\`, then follow it.`,
         "- If multiple could apply: choose the most specific one, then read/follow it.",
         "- If none clearly apply: do not read any SKILL.md.",
+        "Skills encode expertise that improves output quality. Skipping them produces worse results even when the task seems simple.",
         "Constraints: never read more than one skill up front; only read after selecting.",
         trimmed,
         "",

package/dist/agents/taskmaster-tools.js

@@ -27,6 +27,7 @@ import { createContactUpdateTool } from "./tools/contact-update-tool.js";
 import { createRelayMessageTool } from "./tools/relay-message-tool.js";
 import { createSkillReadTool } from "./tools/skill-read-tool.js";
 import { createApiKeysTool } from "./tools/apikeys-tool.js";
+import { createImageGenerateTool } from "./tools/image-generate-tool.js";
 export function createTaskmasterTools(options) {
     const imageTool = options?.agentDir?.trim()
         ? createImageTool({
@@ -121,6 +122,11 @@ export function createTaskmasterTools(options) {
         ...(webSearchTool ? [webSearchTool] : []),
         ...(webFetchTool ? [webFetchTool] : []),
         ...(imageTool ? [imageTool] : []),
+        createImageGenerateTool({
+            config: options?.config,
+            agentDir: options?.agentDir,
+            workspaceDir: options?.workspaceDir,
+        }),
         ...(documentTool ? [documentTool] : []),
         createCurrentTimeTool({ config: options?.config }),
         createAuthorizeAdminTool(),

package/dist/agents/tool-policy.js

@@ -60,6 +60,7 @@ export const TOOL_GROUPS = {
         "web_search",
         "web_fetch",
         "image",
+        "image_generate",
         "current_time",
         "authorize_admin",
         "revoke_admin",
@@ -116,6 +117,7 @@ const TOOL_PROFILES = {
             "contact_update",
             "relay_message",
             "memory_save_media",
+            "image_generate",
         ],
         deny: [...PROFILE_NEVER_GRANT],
     },

package/dist/agents/tools/image-generate-api.js

@@ -0,0 +1,154 @@
+import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { fetchWithTimeout, normalizeBaseUrl, readErrorResponse } from "../../media-understanding/providers/shared.js";
+const log = createSubsystemLogger("image-gen");
+/* ------------------------------------------------------------------ */
+/*  Constants                                                         */
+/* ------------------------------------------------------------------ */
+const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const DEFAULT_TIMEOUT_MS = 120_000;
+const GEMINI_IMAGE_MODELS = new Set([
+    "gemini-2.5-flash-image",
+    "gemini-3-pro-image-preview",
+]);
+/* ------------------------------------------------------------------ */
+/*  Model detection                                                   */
+/* ------------------------------------------------------------------ */
+export function isGeminiImageModel(model) {
+    return GEMINI_IMAGE_MODELS.has(model);
+}
+/* ------------------------------------------------------------------ */
+/*  Gemini native image generation (:generateContent)                 */
+/* ------------------------------------------------------------------ */
+export async function generateImageGemini(params) {
+    const fetchFn = params.fetchFn ?? fetch;
+    const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_BASE_URL);
+    const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const url = `${baseUrl}/models/${params.model}:generateContent`;
+    const headers = new Headers();
+    headers.set("content-type", "application/json");
+    headers.set("x-goog-api-key", params.apiKey);
+    /* Build generationConfig — imageConfig only when there is something to set */
+    const generationConfig = {
+        responseModalities: ["text", "image"],
+    };
+    const imageConfig = {};
+    if (params.aspectRatio)
+        imageConfig.aspectRatio = params.aspectRatio;
+    if (params.resolution)
+        imageConfig.imageSize = params.resolution;
+    if (Object.keys(imageConfig).length > 0) {
+        generationConfig.imageConfig = imageConfig;
+    }
+    const body = {
+        contents: [{ parts: [{ text: params.prompt }] }],
+        generationConfig,
+    };
+    log.info("gemini request", { url, model: params.model, body: JSON.stringify(body) });
+    const res = await fetchWithTimeout(url, { method: "POST", headers, body: JSON.stringify(body) }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        const detail = await readErrorResponse(res);
+        log.error("gemini HTTP error", { status: res.status, detail });
+        const suffix = detail ? `: ${detail}` : "";
+        throw new Error(`Image generation failed (HTTP ${res.status})${suffix}`);
+    }
+    // Parse and log response structure (truncate base64 to avoid log explosion)
+    const rawPayload = await res.json();
+    const payloadForLog = JSON.stringify(rawPayload, (_key, value) => {
+        if (typeof value === "string" && value.length > 200)
+            return `${value.slice(0, 200)}...[${value.length} chars]`;
+        return value;
+    });
+    log.info("gemini response", { payload: payloadForLog });
+    const payload = rawPayload;
+    const parts = payload.candidates?.[0]?.content?.parts ?? [];
+    // Log the keys present in each part so we can see the actual field names
+    log.info("gemini response parts", {
+        candidateCount: payload.candidates?.length ?? 0,
+        partCount: parts.length,
+        partKeys: parts.map((p) => Object.keys(p)),
+    });
+    const images = [];
+    const textParts = [];
+    for (const part of parts) {
+        // Check both snake_case (REST) and camelCase (SDK) field names
+        const inlineData = (part.inline_data ?? part.inlineData);
+        if (inlineData?.data) {
+            images.push({
+                base64: inlineData.data,
+                mimeType: inlineData.mime_type ?? inlineData.mimeType ?? "image/png",
+            });
+        }
+        else if (typeof part.text === "string" && part.text.trim()) {
+            textParts.push(part.text.trim());
+        }
+    }
+    if (images.length === 0) {
+        log.error("gemini: no images found in response", {
+            partCount: parts.length,
+            partKeys: parts.map((p) => Object.keys(p)),
+        });
+        throw new Error("Image generation returned no images");
+    }
+    const result = { images, model: params.model };
+    if (textParts.length > 0) {
+        result.text = textParts.join("\n");
+    }
+    return result;
+}
+/* ------------------------------------------------------------------ */
+/*  Imagen 4 image generation (:predict)                              */
+/* ------------------------------------------------------------------ */
+export async function generateImageImagen(params) {
+    const fetchFn = params.fetchFn ?? fetch;
+    const baseUrl = normalizeBaseUrl(params.baseUrl, DEFAULT_BASE_URL);
+    const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const url = `${baseUrl}/models/${params.model}:predict`;
+    const headers = new Headers();
+    headers.set("content-type", "application/json");
+    headers.set("x-goog-api-key", params.apiKey);
+    /* Only include parameters that are actually provided */
+    const parameters = {};
+    if (params.aspectRatio)
+        parameters.aspectRatio = params.aspectRatio;
+    if (params.resolution)
+        parameters.imageSize = params.resolution;
+    if (params.personGeneration)
+        parameters.personGeneration = params.personGeneration;
+    if (params.sampleCount !== undefined && params.sampleCount >= 1) {
+        parameters.sampleCount = params.sampleCount;
+    }
+    const body = {
+        instances: [{ prompt: params.prompt }],
+        parameters,
+    };
+    log.info("imagen request", { url, model: params.model, body: JSON.stringify(body) });
+    const res = await fetchWithTimeout(url, { method: "POST", headers, body: JSON.stringify(body) }, timeoutMs, fetchFn);
+    if (!res.ok) {
+        const detail = await readErrorResponse(res);
+        log.error("imagen HTTP error", { status: res.status, detail });
+        const suffix = detail ? `: ${detail}` : "";
+        throw new Error(`Image generation failed (HTTP ${res.status})${suffix}`);
+    }
+    const rawPayload = await res.json();
+    const payloadForLog = JSON.stringify(rawPayload, (_key, value) => {
+        if (typeof value === "string" && value.length > 200)
+            return `${value.slice(0, 200)}...[${value.length} chars]`;
+        return value;
+    });
+    log.info("imagen response", { payload: payloadForLog });
+    const payload = rawPayload;
+    const predictions = payload.predictions ?? [];
+    const images = [];
+    for (const pred of predictions) {
+        if (pred.bytesBase64Encoded && pred.mimeType) {
+            images.push({
+                base64: pred.bytesBase64Encoded,
+                mimeType: pred.mimeType,
+            });
+        }
+    }
+    if (images.length === 0) {
+        throw new Error("Image generation returned no images");
+    }
+    return { images, model: params.model };
+}

package/dist/agents/tools/image-generate-tool.js

@@ -0,0 +1,145 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Type } from "@sinclair/typebox";
+import { requireApiKey, resolveApiKeyForProvider } from "../model-auth.js";
+import { generateImageGemini, generateImageImagen, isGeminiImageModel, } from "./image-generate-api.js";
+import { createSubsystemLogger } from "../../logging/subsystem.js";
+import { sanitizeToolResultImages } from "../tool-images.js";
+import { readNumberParam, readStringParam } from "./common.js";
+const log = createSubsystemLogger("image-gen");
+/* ------------------------------------------------------------------ */
+/*  Constants                                                         */
+/* ------------------------------------------------------------------ */
+const SUPPORTED_MODELS = new Set([
+    "gemini-2.5-flash-image",
+    "gemini-3-pro-image-preview",
+    "imagen-4.0-generate-001",
+    "imagen-4.0-ultra-generate-001",
+    "imagen-4.0-fast-generate-001",
+]);
+const DEFAULT_MODEL = "gemini-2.5-flash-image";
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                           */
+/* ------------------------------------------------------------------ */
+function slugify(text, maxLen = 40) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, maxLen);
+}
+function extensionForMime(mimeType) {
+    return mimeType.includes("jpeg") ? "jpg" : "png";
+}
+/* ------------------------------------------------------------------ */
+/*  Tool factory                                                      */
+/* ------------------------------------------------------------------ */
+export function createImageGenerateTool(options) {
+    log.info("image_generate tool registered", { workspaceDir: options?.workspaceDir });
+    return {
+        label: "Image Generate",
+        name: "image_generate",
+        description: "Generate images using Google AI. Image quality depends heavily on model choice and prompt engineering — " +
+            "the image-gen skill provides expert guidance for both. " +
+            "Gemini models: gemini-2.5-flash-image (fast), gemini-3-pro-image-preview (pro, 4K, text rendering). " +
+            "Imagen models: imagen-4.0-generate-001, imagen-4.0-ultra-generate-001, imagen-4.0-fast-generate-001. " +
+            "numberOfImages and personGeneration apply to Imagen models only.",
+        parameters: Type.Object({
+            prompt: Type.String({ description: "The image generation prompt." }),
+            model: Type.Optional(Type.String({ description: "Model ID. Default: gemini-2.5-flash-image." })),
+            aspectRatio: Type.Optional(Type.String({ description: "e.g. 1:1, 16:9, 9:16, 3:4, 4:3. Gemini also supports 2:3, 3:2, 4:5, 5:4, 21:9." })),
+            resolution: Type.Optional(Type.String({ description: "1K, 2K, or 4K (4K: gemini-3-pro-image-preview only)." })),
+            numberOfImages: Type.Optional(Type.Number({ description: "1-4 images per request. Imagen models only." })),
+            personGeneration: Type.Optional(Type.String({ description: "dont_allow, allow_adult, allow_all. Imagen models only." })),
+        }),
+        execute: async (_toolCallId, args) => {
+            log.info("image_generate execute called", { toolCallId: _toolCallId, args });
+            const params = args && typeof args === "object" ? args : {};
+            /* --- Parse parameters ---------------------------------------- */
+            const prompt = readStringParam(params, "prompt", { required: true });
+            const modelRaw = readStringParam(params, "model") ?? DEFAULT_MODEL;
+            const aspectRatio = readStringParam(params, "aspectRatio");
+            const resolution = readStringParam(params, "resolution");
+            const numberOfImages = readNumberParam(params, "numberOfImages", { integer: true });
+            const personGeneration = readStringParam(params, "personGeneration");
+            /* --- Validate model ------------------------------------------ */
+            if (!SUPPORTED_MODELS.has(modelRaw)) {
+                throw new Error(`Unsupported model "${modelRaw}". Supported: ${[...SUPPORTED_MODELS].join(", ")}`);
+            }
+            /* --- Resolve API key ----------------------------------------- */
+            const auth = await resolveApiKeyForProvider({
+                provider: "google",
+                cfg: options?.config,
+                agentDir: options?.agentDir,
+            });
+            const apiKey = requireApiKey(auth, "google");
+            /* --- Call the appropriate backend ---------------------------- */
+            const isGemini = isGeminiImageModel(modelRaw);
+            const result = isGemini
+                ? await generateImageGemini({
+                    apiKey,
+                    model: modelRaw,
+                    prompt,
+                    aspectRatio,
+                    resolution,
+                })
+                : await generateImageImagen({
+                    apiKey,
+                    model: modelRaw,
+                    prompt,
+                    aspectRatio,
+                    resolution,
+                    sampleCount: numberOfImages,
+                    personGeneration,
+                });
+            /* --- Save images to disk ------------------------------------ */
+            const workspaceDir = options?.workspaceDir?.trim();
+            const uploadDir = workspaceDir
+                ? path.join(workspaceDir, "uploads", "generated")
+                : path.join(process.cwd(), "uploads", "generated");
+            await fs.mkdir(uploadDir, { recursive: true });
+            const timestamp = Date.now();
+            const slug = slugify(prompt);
+            const savedPaths = [];
+            for (let i = 0; i < result.images.length; i++) {
+                const img = result.images[i];
+                const ext = extensionForMime(img.mimeType);
+                const suffix = result.images.length > 1 ? `-${i + 1}` : "";
+                const filename = `${timestamp}-${slug}${suffix}.${ext}`;
+                const filePath = path.join(uploadDir, filename);
+                await fs.writeFile(filePath, Buffer.from(img.base64, "base64"));
+                savedPaths.push(filePath);
+            }
+            /* --- Return result ------------------------------------------- */
+            // Build content with ALL images as base64 blocks plus MEDIA: annotations
+            // for the chat sanitizer to convert to /api/media URLs.
+            // The text block uses MEDIA: format (not human-readable file paths) so the
+            // sanitizer can extract paths and strip the text before display.
+            const content = [];
+            // One MEDIA: annotation per image (sanitizer converts these to URL blocks)
+            const mediaLines = savedPaths.map((p) => `MEDIA:${p}`).join("\n");
+            content.push({ type: "text", text: mediaLines });
+            // Base64 image blocks for ALL images (sanitizer strips these for bandwidth)
+            for (const img of result.images) {
+                content.push({
+                    type: "image",
+                    data: img.base64,
+                    mimeType: img.mimeType,
+                });
+            }
+            log.info("image_generate returning", {
+                imageCount: result.images.length,
+                paths: savedPaths,
+            });
+            const toolResult = {
+                content,
+                details: {
+                    model: result.model,
+                    prompt,
+                    paths: savedPaths,
+                },
+            };
+            return await sanitizeToolResultImages(toolResult, "Image Generate");
+        },
+    };
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.98",
-  "commit": "2c46716f6bfa85862ca9241069064d0860ce4f72",
-  "builtAt": "2026-02-21T19:47:09.017Z"
+  "version": "1.0.100",
+  "commit": "afd8ec8222bfb6bac4c7e8839b3c78c9e7df2575",
+  "builtAt": "2026-02-22T20:15:07.050Z"
 }