agiagent-dev 2026.1.39 → 2026.1.40

package/dist/node-host/resume-docx.js

@@ -0,0 +1,266 @@
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function truncateText(s, max = 180) {
+    const t = String(s ?? "");
+    if (t.length <= max) {
+        return t;
+    }
+    return `${t.slice(0, max - 3)}...`;
+}
+async function fileExists(p) {
+    try {
+        const st = await fs.stat(p);
+        return st.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeOsPlatform(platform) {
+    const p = platform.trim().toLowerCase();
+    return p.startsWith("win") ? "win32" : p;
+}
+async function findBundledScript(scriptBasename) {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // dist/node-host/* -> walk up to find package root containing skills/resume-docx/scripts
+    let cur = here;
+    for (let i = 0; i < 8; i++) {
+        const candidate = path.join(cur, "skills", "resume-docx", "scripts", scriptBasename);
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+        const next = path.dirname(cur);
+        if (next === cur) {
+            break;
+        }
+        cur = next;
+    }
+    throw new Error(`Bundled resume-docx script not found: ${scriptBasename}. Please update/reinstall agiagent-dev.`);
+}
+async function runCapture(argv, opts) {
+    const cwd = opts?.cwd;
+    const timeoutMs = typeof opts?.timeoutMs === "number" ? opts.timeoutMs : undefined;
+    return await new Promise((resolve) => {
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let settled = false;
+        let timer;
+        let child = null;
+        try {
+            child = spawn(argv[0], argv.slice(1), {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                windowsHide: true,
+            });
+        }
+        catch (err) {
+            resolve({
+                exitCode: null,
+                stdout: "",
+                stderr: "",
+                error: err instanceof Error ? err.message : String(err),
+                timedOut: false,
+            });
+            return;
+        }
+        const finalize = (exitCode, error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timer) {
+                clearTimeout(timer);
+            }
+            resolve({
+                exitCode,
+                stdout,
+                stderr,
+                error,
+                timedOut,
+            });
+        };
+        child.stdout?.on("data", (chunk) => {
+            stdout += String(chunk ?? "");
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk ?? "");
+        });
+        if (timeoutMs && timeoutMs > 0) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                try {
+                    child?.kill("SIGKILL");
+                }
+                catch {
+                    // ignore
+                }
+            }, timeoutMs);
+        }
+        child.on("error", (err) => finalize(null, err.message));
+        child.on("exit", (code) => finalize(code === null ? null : code, null));
+    });
+}
+async function resolvePythonCommand() {
+    const candidates = [
+        { argv: ["python3"], label: "python3" },
+        { argv: ["python"], label: "python" },
+    ];
+    if (normalizeOsPlatform(process.platform) === "win32") {
+        candidates.push({ argv: ["py", "-3"], label: "py -3" });
+    }
+    for (const cand of candidates) {
+        const res = await runCapture([...cand.argv, "-c", "import sys; print(sys.version_info[0])"], {
+            timeoutMs: 10_000,
+        });
+        if (res.exitCode === 0 && res.stdout.trim() === "3") {
+            return cand;
+        }
+    }
+    throw new Error("Python 3 not found on this device. Install Python 3 and ensure it is on PATH (python3/python or py -3 on Windows).");
+}
+async function ensurePythonDocx(python) {
+    const res = await runCapture([...python.argv, "-c", "import docx; print('python-docx OK')"], {
+        timeoutMs: 15_000,
+    });
+    if (res.exitCode === 0) {
+        return;
+    }
+    const platform = normalizeOsPlatform(process.platform);
+    const recommended = platform === "win32"
+        ? "py -3 -m pip install python-docx"
+        : `${python.label.includes("python3") ? "pip3" : "pip"} install python-docx`;
+    throw new Error(`Missing dependency: python-docx. Install it on your device, then retry.\nRecommended: ${recommended}`);
+}
+export async function resumeDocxCheck() {
+    const python = await resolvePythonCommand();
+    await ensurePythonDocx(python);
+    return { ok: true, python: python.label };
+}
+export async function resumeDocxExtract(params) {
+    const docxPath = String(params.docxPath ?? "").trim();
+    if (!docxPath) {
+        throw new Error("INVALID_REQUEST: docxPath required");
+    }
+    if (!docxPath.toLowerCase().endsWith(".docx")) {
+        throw new Error(`INVALID_REQUEST: docxPath must be a .docx file: ${docxPath}`);
+    }
+    const st = await fs.stat(docxPath).catch(() => null);
+    if (!st || !st.isFile()) {
+        throw new Error(`INVALID_REQUEST: docxPath is not a file: ${docxPath}`);
+    }
+    const python = await resolvePythonCommand();
+    await ensurePythonDocx(python);
+    const extractScript = await findBundledScript("resume_docx_extract.py");
+    const outPath = path.join(os.tmpdir(), `agiagent-resume-schema-${crypto.randomUUID()}.json`);
+    const res = await runCapture([...python.argv, extractScript, docxPath, "--out", outPath], {
+        timeoutMs: 120_000,
+    });
+    if (res.exitCode !== 0) {
+        throw new Error(`resume-docx extract failed (exit=${res.exitCode ?? "?"}): ${truncateText((res.stderr || res.stdout || res.error || "").trim(), 500)}`);
+    }
+    const raw = await fs.readFile(outPath, "utf8");
+    await fs.unlink(outPath).catch(() => { });
+    const parsed = JSON.parse(raw);
+    const mode = params.mode === "full" ? "full" : "digest";
+    if (mode === "full") {
+        return { ok: true, mode, schema: parsed };
+    }
+    const headings = Array.isArray(parsed?.headings) ? parsed.headings : [];
+    const skillsTable = parsed?.skills_table ?? null;
+    const sections = parsed?.sections ?? {};
+    const summary = sections?.summary ?? null;
+    const experience = sections?.experience ?? null;
+    const paragraphs = Array.isArray(parsed?.paragraphs) ? parsed.paragraphs : [];
+    const paragraphsSample = paragraphs
+        .filter((p) => p && typeof p === "object" && typeof p.text === "string" && p.text.trim())
+        .slice(0, 40)
+        .map((p) => ({
+        paragraph_index: p.paragraph_index,
+        text: truncateText(p.text, 220),
+        style: typeof p.style === "string" ? p.style : "",
+    }));
+    const digest = {
+        schema_version: parsed?.schema_version ?? 2,
+        docx_path: parsed?.docx_path ?? docxPath,
+        fingerprint: parsed?.fingerprint ?? null,
+        stats: parsed?.stats ?? null,
+        skills_table: skillsTable,
+        headings,
+        sections: {
+            summary: summary
+                ? {
+                    heading: summary.heading,
+                    heading_index: summary.heading_index,
+                    end_index: summary.end_index,
+                    bullets: Array.isArray(summary.bullets)
+                        ? summary.bullets.slice(0, 30).map((b) => ({
+                            paragraph_index: b.paragraph_index,
+                            text: truncateText(b.text ?? "", 220),
+                            isNumbered: Boolean(b.isNumbered),
+                        }))
+                        : [],
+                }
+                : null,
+            experience: experience
+                ? {
+                    heading: experience.heading,
+                    heading_index: experience.heading_index,
+                    end_index: experience.end_index,
+                    blocks: Array.isArray(experience.blocks)
+                        ? experience.blocks.slice(0, 30).map((b) => ({
+                            id: b.id,
+                            header: truncateText(b.header ?? "", 220),
+                            header_index: b.header_index ?? null,
+                            first_bullet_index: b.first_bullet_index,
+                            last_bullet_index: b.last_bullet_index,
+                            bullet_count: b.bullet_count ?? null,
+                        }))
+                        : [],
+                }
+                : null,
+        },
+        paragraphs_sample: paragraphsSample,
+    };
+    return { ok: true, mode, schema: digest };
+}
+export async function resumeDocxApply(params) {
+    const inPath = String(params.inPath ?? "").trim();
+    const outPath = String(params.outPath ?? "").trim();
+    if (!inPath || !outPath) {
+        throw new Error("INVALID_REQUEST: inPath and outPath required");
+    }
+    if (!inPath.toLowerCase().endsWith(".docx")) {
+        throw new Error(`INVALID_REQUEST: inPath must be a .docx file: ${inPath}`);
+    }
+    if (!outPath.toLowerCase().endsWith(".docx")) {
+        throw new Error(`INVALID_REQUEST: outPath must be a .docx file: ${outPath}`);
+    }
+    const st = await fs.stat(inPath).catch(() => null);
+    if (!st || !st.isFile()) {
+        throw new Error(`INVALID_REQUEST: inPath is not a file: ${inPath}`);
+    }
+    const python = await resolvePythonCommand();
+    await ensurePythonDocx(python);
+    const applyScript = await findBundledScript("resume_docx_apply.py");
+    const patchPath = path.join(os.tmpdir(), `agiagent-resume-patch-${crypto.randomUUID()}.json`);
+    await fs.writeFile(patchPath, JSON.stringify(params.patch ?? {}, null, 2), "utf8");
+    try {
+        const res = await runCapture([...python.argv, applyScript, "--in", inPath, "--patch", patchPath, "--out", outPath], { timeoutMs: 180_000 });
+        if (res.exitCode !== 0) {
+            throw new Error(`resume-docx apply failed (exit=${res.exitCode ?? "?"}): ${truncateText((res.stderr || res.stdout || res.error || "").trim(), 700)}`);
+        }
+    }
+    finally {
+        await fs.unlink(patchPath).catch(() => { });
+    }
+    const outStat = await fs.stat(outPath).catch(() => null);
+    if (!outStat || !outStat.isFile()) {
+        throw new Error(`resume-docx apply did not produce output: ${outPath}`);
+    }
+    return { ok: true, outPath };
+}

package/dist/node-host/runner.js

@@ -3,6 +3,7 @@ import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import fsPromises from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveAgentConfig } from "../agents/agent-scope.js";
@@ -21,6 +22,7 @@ import { detectMime } from "../media/mime.js";
 import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../utils/message-channel.js";
 import { VERSION } from "../version.js";
 import { ensureNodeHostConfig, saveNodeHostConfig } from "./config.js";
+import { resumeDocxApply, resumeDocxCheck, resumeDocxExtract } from "./resume-docx.js";
 function resolveExecSecurity(value) {
     return value === "deny" || value === "allowlist" || value === "full" ? value : "allowlist";
 }
@@ -289,69 +291,150 @@ async function runCommand(argv, cwd, env, timeoutMs) {
         let truncated = false;
         let timedOut = false;
         let settled = false;
-        const child = spawn(argv[0], argv.slice(1), {
-            cwd,
-            env,
-            stdio: ["ignore", "pipe", "pipe"],
-            windowsHide: true,
-        });
-        const onChunk = (chunk, target) => {
-            if (outputLen >= OUTPUT_CAP) {
-                truncated = true;
-                return;
-            }
-            const remaining = OUTPUT_CAP - outputLen;
-            const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
-            const str = slice.toString("utf8");
-            outputLen += slice.length;
-            if (target === "stdout") {
-                stdout += str;
+        const WINDOWS_INLINE_CMD_SOFT_LIMIT = 7000;
+        const POSIX_INLINE_CMD_SOFT_LIMIT = 50_000;
+        const platform = process.platform;
+        let cleanupTempFile = null;
+        const materializeShellIfNeeded = async () => {
+            if (!Array.isArray(argv) || argv.length < 2) {
+                return argv;
             }
-            else {
-                stderr += str;
+            const a0 = String(argv[0] ?? "").toLowerCase();
+            if (platform === "win32") {
+                const idx = argv.findIndex((a) => String(a).toLowerCase() === "-command");
+                const cmd = idx >= 0 ? String(argv[idx + 1] ?? "") : "";
+                if (a0.includes("powershell") && idx >= 0 && cmd.length > WINDOWS_INLINE_CMD_SOFT_LIMIT) {
+                    const tmp = path.join(os.tmpdir(), `agiagent-cmd-${crypto.randomUUID()}.ps1`);
+                    cleanupTempFile = tmp;
+                    await fsPromises.writeFile(tmp, cmd, "utf8");
+                    // Keep PowerShell non-interactive and bypass policy for this one run.
+                    return [
+                        argv[0],
+                        "-NoProfile",
+                        "-NonInteractive",
+                        "-ExecutionPolicy",
+                        "Bypass",
+                        "-File",
+                        tmp,
+                    ];
+                }
+                return argv;
             }
-            if (chunk.length > remaining) {
-                truncated = true;
+            // POSIX shell: `/bin/sh -lc "<script>"` can also hit argv limits on some systems.
+            const cmd = argv.length >= 3 && argv[1] === "-lc" ? String(argv[2] ?? "") : "";
+            if (a0 === "/bin/sh" && argv[1] === "-lc" && cmd.length > POSIX_INLINE_CMD_SOFT_LIMIT) {
+                const tmp = path.join(os.tmpdir(), `agiagent-cmd-${crypto.randomUUID()}.sh`);
+                cleanupTempFile = tmp;
+                // Use a plain sh script; keep it simple and avoid bash-isms.
+                await fsPromises.writeFile(tmp, `${cmd}\n`, "utf8");
+                return ["/bin/sh", tmp];
             }
+            return argv;
         };
-        child.stdout?.on("data", (chunk) => onChunk(chunk, "stdout"));
-        child.stderr?.on("data", (chunk) => onChunk(chunk, "stderr"));
-        let timer;
-        if (timeoutMs && timeoutMs > 0) {
-            timer = setTimeout(() => {
-                timedOut = true;
-                try {
-                    child.kill("SIGKILL");
+        let child;
+        try {
+            // Note: materializeShellIfNeeded() is async but runCommand() is sync inside Promise ctor.
+            // We kick off an async IIFE to keep the outer signature stable.
+            void (async () => {
+                const effectiveArgv = await materializeShellIfNeeded();
+                child = spawn(effectiveArgv[0], effectiveArgv.slice(1), {
+                    cwd,
+                    env,
+                    stdio: ["ignore", "pipe", "pipe"],
+                    windowsHide: true,
+                });
+                const onChunk = (chunk, target) => {
+                    if (outputLen >= OUTPUT_CAP) {
+                        truncated = true;
+                        return;
+                    }
+                    const remaining = OUTPUT_CAP - outputLen;
+                    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+                    const str = slice.toString("utf8");
+                    outputLen += slice.length;
+                    if (target === "stdout") {
+                        stdout += str;
+                    }
+                    else {
+                        stderr += str;
+                    }
+                    if (chunk.length > remaining) {
+                        truncated = true;
+                    }
+                };
+                child.stdout?.on("data", (chunk) => onChunk(chunk, "stdout"));
+                child.stderr?.on("data", (chunk) => onChunk(chunk, "stderr"));
+                let timer;
+                if (timeoutMs && timeoutMs > 0) {
+                    timer = setTimeout(() => {
+                        timedOut = true;
+                        try {
+                            child.kill("SIGKILL");
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }, timeoutMs);
                 }
-                catch {
-                    // ignore
+                const finalize = (exitCode, error) => {
+                    if (settled) {
+                        return;
+                    }
+                    settled = true;
+                    if (timer) {
+                        clearTimeout(timer);
+                    }
+                    if (cleanupTempFile) {
+                        void fsPromises.unlink(cleanupTempFile).catch(() => { });
+                    }
+                    resolve({
+                        exitCode,
+                        timedOut,
+                        success: exitCode === 0 && !timedOut && !error,
+                        stdout,
+                        stderr,
+                        error: error ?? null,
+                        truncated,
+                    });
+                };
+                child.on("error", (err) => {
+                    finalize(undefined, err.message);
+                });
+                child.on("exit", (code) => {
+                    finalize(code === null ? undefined : code, null);
+                });
+            })().catch((err) => {
+                // Covers failures in materializeShellIfNeeded().
+                if (cleanupTempFile) {
+                    void fsPromises.unlink(cleanupTempFile).catch(() => { });
                 }
-            }, timeoutMs);
+                resolve({
+                    exitCode: undefined,
+                    timedOut: false,
+                    success: false,
+                    stdout: "",
+                    stderr: "",
+                    error: String(err),
+                    truncated: false,
+                });
+            });
+            return;
         }
-        const finalize = (exitCode, error) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            if (timer) {
-                clearTimeout(timer);
+        catch (err) {
+            if (cleanupTempFile) {
+                void fsPromises.unlink(cleanupTempFile).catch(() => { });
             }
             resolve({
-                exitCode,
-                timedOut,
-                success: exitCode === 0 && !timedOut && !error,
-                stdout,
-                stderr,
-                error: error ?? null,
-                truncated,
+                exitCode: undefined,
+                timedOut: false,
+                success: false,
+                stdout: "",
+                stderr: "",
+                error: err instanceof Error ? err.message : String(err),
+                truncated: false,
             });
-        };
-        child.on("error", (err) => {
-            finalize(undefined, err.message);
-        });
-        child.on("exit", (code) => {
-            finalize(code === null ? undefined : code, null);
-        });
+            return;
+        }
     });
 }
 function resolveEnvPath(env) {
@@ -473,6 +556,9 @@ export async function runNodeHost(opts) {
             "system.which",
             "system.execApprovals.get",
             "system.execApprovals.set",
+            "resume.docx.check",
+            "resume.docx.extract",
+            "resume.docx.apply",
             "gmail.profile",
             "gmail.labels.list",
             "gmail.messages.search",
@@ -481,6 +567,7 @@ export async function runNodeHost(opts) {
             "gmail.messages.send",
             "gmail.messages.reply",
             "gmail.messages.modify",
+            "gmail.drafts.create",
             "gmail.attachments.get",
             ...(browserProxyEnabled ? ["browser.proxy", "browser.stagehand"] : []),
         ],
@@ -493,7 +580,13 @@ export async function runNodeHost(opts) {
             if (evt.event === "node.invoke.request") {
                 const payload = coerceNodeInvokePayload(evt.payload);
                 if (payload) {
-                    void handleInvoke(payload, client, skillBins);
+                    void handleInvoke(payload, client, skillBins).catch(async (err) => {
+                        // Ensure we never crash the node host on tool errors.
+                        await sendInvokeResult(client, payload, {
+                            ok: false,
+                            error: { code: "INTERNAL_ERROR", message: String(err) },
+                        });
+                    });
                 }
                 return;
             }
@@ -538,7 +631,64 @@ export async function runNodeHost(opts) {
     await new Promise(() => { });
 }
 async function handleInvoke(frame, client, skillBins) {
+    try {
+        await handleInvokeInner(frame, client, skillBins);
+    }
+    catch (err) {
+        // Last-resort safety net: never allow tool errors to crash the node host.
+        await sendInvokeResult(client, frame, {
+            ok: false,
+            error: { code: "INTERNAL_ERROR", message: String(err) },
+        });
+    }
+}
+async function handleInvokeInner(frame, client, skillBins) {
     const command = String(frame.command ?? "");
+    if (command === "resume.docx.check") {
+        try {
+            // Params are currently unused but keep decoding for forward-compatibility.
+            if (frame.paramsJSON) {
+                decodeParams(frame.paramsJSON);
+            }
+            const result = await resumeDocxCheck();
+            await sendInvokeResult(client, frame, { ok: true, payloadJSON: JSON.stringify(result) });
+        }
+        catch (err) {
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code: "INVALID_REQUEST", message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "resume.docx.extract") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const result = await resumeDocxExtract(params);
+            await sendInvokeResult(client, frame, { ok: true, payloadJSON: JSON.stringify(result) });
+        }
+        catch (err) {
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code: "INVALID_REQUEST", message: String(err) },
+            });
+        }
+        return;
+    }
+    if (command === "resume.docx.apply") {
+        try {
+            const params = decodeParams(frame.paramsJSON);
+            const result = await resumeDocxApply(params);
+            await sendInvokeResult(client, frame, { ok: true, payloadJSON: JSON.stringify(result) });
+        }
+        catch (err) {
+            await sendInvokeResult(client, frame, {
+                ok: false,
+                error: { code: "INVALID_REQUEST", message: String(err) },
+            });
+        }
+        return;
+    }
     if (command.startsWith("gmail.")) {
         try {
             const result = await handleGmailInvoke(command, frame, client);
@@ -1466,6 +1616,73 @@ async function handleGmailInvoke(command, frame, client) {
             body: JSON.stringify({ raw, threadId }),
         });
     }
+    // Create a Gmail draft. Supports both new drafts and reply-in-thread drafts.
+    // When messageId is provided the draft is threaded as a reply (fetches headers
+    // automatically). Otherwise a standalone draft is created to the given `to`.
+    if (command === "gmail.drafts.create") {
+        const params = decodeParams(frame.paramsJSON);
+        const body = String(params.body ?? "");
+        const attachments = await loadAttachments(params.attachments);
+        // If messageId is provided, thread as a reply (like messages.reply but draft)
+        if (params.messageId) {
+            const messageId = String(params.messageId).trim();
+            const metaUsp = new URLSearchParams();
+            metaUsp.set("format", "metadata");
+            for (const h of ["Message-ID", "References", "Subject", "From", "Reply-To"]) {
+                metaUsp.append("metadataHeaders", h);
+            }
+            const message = (await gmailFetch(token, `/messages/${encodeURIComponent(messageId)}?${metaUsp.toString()}`, { method: "GET" }));
+            const fetchedThreadId = typeof message?.threadId === "string" ? message.threadId.trim() : "";
+            const headers = Array.isArray(message?.payload?.headers) ? message.payload.headers : [];
+            const from = extractEmailAddress(parseHeaderValue(headers, "Reply-To") || parseHeaderValue(headers, "From"));
+            const origSubject = parseHeaderValue(headers, "Subject");
+            const subject = ensureSubjectReply(origSubject);
+            const inReplyTo = parseHeaderValue(headers, "Message-ID");
+            const references = parseHeaderValue(headers, "References");
+            const nextRefs = [references, inReplyTo]
+                .map((v) => String(v ?? "").trim())
+                .filter(Boolean)
+                .join(" ")
+                .trim();
+            const mime = buildMimeMessage({
+                headers: {
+                    To: from,
+                    Subject: subject,
+                    ...(inReplyTo ? { "In-Reply-To": inReplyTo } : {}),
+                    ...(nextRefs ? { References: nextRefs } : {}),
+                },
+                textBody: body,
+                attachments,
+            });
+            const raw = base64UrlEncode(Buffer.from(mime, "utf8"));
+            return await gmailFetch(token, "/drafts", {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    message: { raw, ...(fetchedThreadId ? { threadId: fetchedThreadId } : {}) },
+                }),
+            });
+        }
+        // New draft (not a reply) — to a specified recipient
+        const toList = Array.isArray(params.to) ? params.to : [String(params.to ?? "")];
+        const to = toList.map((v) => String(v).trim()).filter(Boolean);
+        if (to.length === 0) {
+            throw new Error("INVALID_REQUEST: to required for new draft");
+        }
+        const subject = String(params.subject ?? "").trim();
+        const threadId = params.threadId ? String(params.threadId).trim() : "";
+        const mime = buildMimeMessage({
+            headers: { To: to.join(", "), Subject: subject },
+            textBody: body,
+            attachments,
+        });
+        const raw = base64UrlEncode(Buffer.from(mime, "utf8"));
+        return await gmailFetch(token, "/drafts", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ message: { raw, ...(threadId ? { threadId } : {}) } }),
+        });
+    }
     throw new Error(`INVALID_REQUEST: unknown gmail command: ${command}`);
 }
 function decodeParams(raw) {

package/extensions/lobster/src/lobster-tool.test.ts

@@ -84,7 +84,7 @@ describe("lobster plugin tool", () => {
       const res = await tool.execute("call1", {
         action: "run",
         pipeline: "noop",
-        timeoutMs: 1000,
+        timeoutMs: 4000,
       });
 
       expect(res.details).toMatchObject({ ok: true, status: "ok" });
@@ -110,7 +110,7 @@ describe("lobster plugin tool", () => {
       const res = await tool.execute("call-noisy", {
         action: "run",
         pipeline: "noop",
-        timeoutMs: 1000,
+        timeoutMs: 4000,
       });
 
       expect(res.details).toMatchObject({ ok: true, status: "ok" });
@@ -200,7 +200,7 @@ describe("lobster plugin tool", () => {
       const res = await tool.execute("call-plugin-config", {
         action: "run",
         pipeline: "noop",
-        timeoutMs: 1000,
+        timeoutMs: 4000,
       });
 
       expect(res.details).toMatchObject({ ok: true, status: "ok" });