@minionry/minion 0.7.36

package/dist/server/cli/headless/mcp-config.js

@@ -0,0 +1,314 @@
+import { existsSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { ensureMachineDir } from '../../../bin/machine-layout.js';
+import { APP_TOOLS_MCP_SERVER_PATH, BROWSER_MCP_SERVER_PATH, IS_COMPILED, MCP_SERVER_PATH, MINIONRY_ROOT, QUALITY_MCP_SERVER_PATH, } from '../../utils/paths.js';
+import { herror, hlog } from './headless-logger.js';
+const APP_TOOLS_MCP_SERVER_NAME = 'minionry-app-tools';
+export const BROWSER_MCP_SERVER_NAME = 'minionry-browser';
+export const QUALITY_MCP_SERVER_NAME = 'minionry-quality';
+const QUALITY_REVIEW_TAB_PREFIX = 'quality-review-';
+let browserHostAttached = false;
+let browserPreflightProbe = null;
+const BROWSER_PREFLIGHT_CACHE_MS = 60_000;
+export function setAgentBrowserHostAttached(attached) {
+    browserHostAttached = attached;
+    browserPreflightProbe = null;
+}
+async function probeBrowserPreflight() {
+    try {
+        const { preflight } = await import('../../services/browser/preflight.js');
+        const result = await preflight();
+        return !result.checks.some((check) => !check.ok && !check.advisory);
+    }
+    catch (error) {
+        herror(`[${new Date().toISOString()}] Browser preflight unavailable, withholding the agent browser surface: ${error instanceof Error ? error.message : String(error)}`);
+        return false;
+    }
+}
+export async function isAgentBrowserSurfaceAvailable(now = Date.now()) {
+    if (!browserHostAttached)
+        return false;
+    if (!existsSync(BROWSER_MCP_SERVER_PATH))
+        return false;
+    if (!browserPreflightProbe || now - browserPreflightProbe.at > BROWSER_PREFLIGHT_CACHE_MS) {
+        browserPreflightProbe = { at: now, ok: probeBrowserPreflight() };
+    }
+    return browserPreflightProbe.ok;
+}
+export const COMPETING_BROWSER_SERVER_PATTERNS = [
+    'playwright',
+    'puppeteer',
+    'browser-use',
+    'browsermcp',
+    'browser-mcp',
+    'chrome-devtools',
+    'chromedevtools',
+    'selenium',
+];
+export function isCompetingBrowserServer(name) {
+    const lc = name.toLowerCase();
+    if (lc === BROWSER_MCP_SERVER_NAME || lc === APP_TOOLS_MCP_SERVER_NAME || lc === QUALITY_MCP_SERVER_NAME)
+        return false;
+    return COMPETING_BROWSER_SERVER_PATTERNS.some((p) => lc.includes(p));
+}
+export function resolveMcpLauncher() {
+    if (IS_COMPILED)
+        return { command: process.execPath, argsPrefix: [] };
+    const candidates = [
+        resolve(MINIONRY_ROOT, 'node_modules/.bin/tsx'),
+        resolve(MINIONRY_ROOT, '../node_modules/.bin/tsx'),
+        resolve(MINIONRY_ROOT, '../../node_modules/.bin/tsx'),
+    ];
+    for (const bin of candidates) {
+        if (existsSync(bin))
+            return { command: bin, argsPrefix: [] };
+    }
+    return { command: 'npx', argsPrefix: ['-y', 'tsx'] };
+}
+function loadUserMcpServers(workingDir, verbose) {
+    const servers = {};
+    const claudeConfigPath = join(homedir(), '.claude.json');
+    if (!existsSync(claudeConfigPath)) {
+        return servers;
+    }
+    try {
+        const claudeConfig = JSON.parse(readFileSync(claudeConfigPath, 'utf-8'));
+        if (claudeConfig.mcpServers && typeof claudeConfig.mcpServers === 'object') {
+            Object.assign(servers, claudeConfig.mcpServers);
+        }
+        if (claudeConfig.projects && typeof claudeConfig.projects === 'object') {
+            for (const [projectPath, projectConfig] of Object.entries(claudeConfig.projects)) {
+                const projectServers = projectConfig?.mcpServers;
+                if (workingDir.startsWith(projectPath) && typeof projectServers === 'object') {
+                    Object.assign(servers, projectServers);
+                }
+            }
+        }
+        if (verbose) {
+            hlog(`[${new Date().toISOString()}] Loaded ${Object.keys(servers).length} user MCP servers from ~/.claude.json`);
+        }
+    }
+    catch (parseError) {
+        herror(`[${new Date().toISOString()}] Failed to parse ~/.claude.json: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    }
+    return servers;
+}
+const MAX_USER_PROMPT_LENGTH = 4000;
+function truncatePrompt(prompt) {
+    const truncated = prompt.slice(0, MAX_USER_PROMPT_LENGTH);
+    const lastSpace = truncated.lastIndexOf(' ');
+    const clean = lastSpace > MAX_USER_PROMPT_LENGTH * 0.8 ? truncated.slice(0, lastSpace) : truncated;
+    return `${clean}... [truncated]`;
+}
+export function sessionGetsQualityMcp(session) {
+    if (!session.tabId)
+        return false;
+    if (session.tabId.startsWith(QUALITY_REVIEW_TAB_PREFIX))
+        return false;
+    if (session.appRunProfile !== undefined)
+        return false;
+    if (session.appTools?.onlyAppId)
+        return false;
+    return true;
+}
+export function resolveQualityMcpOptions(session, transport) {
+    if (!sessionGetsQualityMcp(session))
+        return null;
+    if (!transport.port || !transport.bouncerSecret || !transport.capabilityToken)
+        return null;
+    return { port: transport.port, bouncerSecret: transport.bouncerSecret, capabilityToken: transport.capabilityToken };
+}
+export async function resolveAppToolsMcpContext(runContext, transport) {
+    if (!runContext || !transport.port || !transport.bouncerSecret || !transport.capabilityToken) {
+        return null;
+    }
+    try {
+        const { hasExposedAppTools } = await import('../../mcp/app-tools-bridge.js');
+        if (!hasExposedAppTools(runContext))
+            return null;
+    }
+    catch (error) {
+        herror(`[${new Date().toISOString()}] App-tools roster unavailable, exposing no app tools: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+    return {
+        ...runContext,
+        port: transport.port,
+        bouncerSecret: transport.bouncerSecret,
+        capabilityToken: transport.capabilityToken,
+    };
+}
+export function buildAppToolsMcpEntry(ctx) {
+    if (!existsSync(APP_TOOLS_MCP_SERVER_PATH)) {
+        herror(`[${new Date().toISOString()}] App-tools MCP server not found at ${APP_TOOLS_MCP_SERVER_PATH}`);
+        return null;
+    }
+    const launcher = resolveMcpLauncher();
+    return {
+        command: launcher.command,
+        args: [...launcher.argsPrefix, APP_TOOLS_MCP_SERVER_PATH],
+        description: 'Operations served by the Workshop apps connected to this Space',
+        env: {
+            MINIONRY_PORT: String(ctx.port),
+            MINIONRY_BOUNCER_SECRET: ctx.bouncerSecret,
+            MINIONRY_CAPABILITY_TOKEN: ctx.capabilityToken,
+        },
+    };
+}
+export function buildBrowserMcpEntry(opts) {
+    const env = {
+        MINIONRY_PORT: String(opts.port),
+        MINIONRY_BOUNCER_SECRET: opts.bouncerSecret,
+        MINIONRY_CAPABILITY_TOKEN: opts.capabilityToken,
+    };
+    if (opts.defaultTabId)
+        env.MINIONRY_DEFAULT_TAB_ID = opts.defaultTabId;
+    if (opts.agentLabel)
+        env.MINIONRY_AGENT_LABEL = opts.agentLabel;
+    const launcher = resolveMcpLauncher();
+    return {
+        command: launcher.command,
+        args: [...launcher.argsPrefix, BROWSER_MCP_SERVER_PATH],
+        description: "The user's real, visible browser — navigation, reading, and input on live web pages",
+        env,
+    };
+}
+export function buildQualityMcpEntry(opts) {
+    if (!existsSync(QUALITY_MCP_SERVER_PATH)) {
+        herror(`[${new Date().toISOString()}] Quality MCP server not found at ${QUALITY_MCP_SERVER_PATH}`);
+        return null;
+    }
+    const launcher = resolveMcpLauncher();
+    return {
+        command: launcher.command,
+        args: [...launcher.argsPrefix, QUALITY_MCP_SERVER_PATH],
+        description: "On-demand, read-only quality checks of named files in this Space's code",
+        env: {
+            MINIONRY_PORT: String(opts.port),
+            MINIONRY_BOUNCER_SECRET: opts.bouncerSecret,
+            MINIONRY_CAPABILITY_TOKEN: opts.capabilityToken,
+        },
+    };
+}
+export const BROWSER_SYSTEM_PROMPT = [
+    `This session is connected to the user's REAL browser — the window they can see — through the mcp__${BROWSER_MCP_SERVER_NAME}__browser_* tools. Those tools drive the open web: any site, any page, visibly, as it happens.`,
+    'For ANY interaction with a web page — navigating, reading, clicking, typing, filling a form — you MUST use those browser_* tools, so the user watches every step happen in front of them.',
+    `The mcp__${APP_TOOLS_MCP_SERVER_NAME}__<appId>__<tool> tools are a DIFFERENT surface: operations a connected Minionry app serves over its own content, not the web. Use them for that app's own data, never as a substitute for browsing a page, and never expect them to reach a site.`,
+    'NEVER drive a browser the user cannot see. Do not use your own or another browser (playwright, puppeteer, chromium, browser-use), curl, or WebFetch to visit or act on a page the user asked you to work with; that executes invisibly and is a failure even when the result looks right.',
+    'Work the page in observe->act steps: break the request into small sequential actions, and after each mutating action (click/type/fill) call browser_snapshot to observe the result before choosing the next one.',
+    'If a browser_* tool fails, or an element you expect is missing from the snapshot, call browser_take_screenshot to see the page visually and re-orient; do not silently switch to non-browser tools.',
+    'If browser tools are unavailable or keep failing (connection errors, browser_host_unavailable), STOP and report the problem to the user instead of completing the task another way.',
+].join(' ');
+function eligibleUserServers(workingDir, verbose, browserSession) {
+    const servers = loadUserMcpServers(workingDir, verbose);
+    if (!browserSession)
+        return servers;
+    for (const name of Object.keys(servers)) {
+        if (isCompetingBrowserServer(name)) {
+            delete servers[name];
+            hlog(`[${new Date().toISOString()}] Excluding user MCP server "${name}" for this browser session (${BROWSER_MCP_SERVER_NAME} owns the browser surface)`);
+        }
+    }
+    return servers;
+}
+function buildBouncerEnv(options) {
+    const { userPrompt, deployMode, askUserQuestionRouting, sdkAppRun } = options;
+    const bouncerEnv = {
+        BOUNCER_USE_AI: 'true',
+        MINIONRY_ROOT: MINIONRY_ROOT,
+    };
+    if (deployMode) {
+        bouncerEnv.BOUNCER_DEPLOY_MODE = 'true';
+    }
+    if (userPrompt) {
+        bouncerEnv.BOUNCER_USER_PROMPT = userPrompt.length > MAX_USER_PROMPT_LENGTH
+            ? truncatePrompt(userPrompt)
+            : userPrompt;
+    }
+    if (askUserQuestionRouting) {
+        bouncerEnv.MINIONRY_PORT = String(askUserQuestionRouting.port);
+        bouncerEnv.MINIONRY_TAB_ID = askUserQuestionRouting.tabId;
+        bouncerEnv.MINIONRY_BOUNCER_SECRET = askUserQuestionRouting.bouncerSecret;
+        bouncerEnv.MINIONRY_CAPABILITY_TOKEN = askUserQuestionRouting.capabilityToken;
+    }
+    if (sdkAppRun) {
+        bouncerEnv.BOUNCER_SDK_APP_ID = sdkAppRun.appId;
+        bouncerEnv.BOUNCER_SDK_APP_ORIGIN = sdkAppRun.origin;
+        bouncerEnv.BOUNCER_SDK_SCOPES = sdkAppRun.scopes.join(',');
+        bouncerEnv.BOUNCER_SDK_WORKSPACE_DIR = sdkAppRun.workspaceDir;
+        bouncerEnv.BOUNCER_SDK_SANDBOX_DIR = sdkAppRun.sandboxDir;
+    }
+    return bouncerEnv;
+}
+const MCP_CONFIG_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const MCP_CONFIG_FILE_RE = /^mcp-config-[0-9a-f-]{36}\.json$/i;
+export function removeMcpConfig(configPath) {
+    if (!configPath)
+        return;
+    try {
+        rmSync(configPath, { force: true });
+    }
+    catch (error) {
+        herror(`[${new Date().toISOString()}] Failed to remove MCP config ${configPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function sweepStaleMcpConfigs(configDir, now = Date.now()) {
+    let names;
+    try {
+        names = readdirSync(configDir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!MCP_CONFIG_FILE_RE.test(name))
+            continue;
+        const file = join(configDir, name);
+        try {
+            if (now - statSync(file).mtimeMs > MCP_CONFIG_MAX_AGE_MS)
+                rmSync(file, { force: true });
+        }
+        catch {
+        }
+    }
+}
+export function generateMcpConfig(workingDir, verbose = false, options = {}) {
+    const { sessionId, appTools, browserMcp, qualityMcp } = options;
+    try {
+        if (!existsSync(MCP_SERVER_PATH)) {
+            herror(`[${new Date().toISOString()}] MCP server not found at ${MCP_SERVER_PATH}`);
+            return null;
+        }
+        const bouncerEnv = buildBouncerEnv(options);
+        const launcher = resolveMcpLauncher();
+        const appToolsEntry = appTools ? buildAppToolsMcpEntry(appTools) : null;
+        const browserEntry = browserMcp ? buildBrowserMcpEntry(browserMcp) : null;
+        const qualityEntry = qualityMcp ? buildQualityMcpEntry(qualityMcp) : null;
+        const mcpServers = {
+            'minionry-bouncer': {
+                command: launcher.command,
+                args: [...launcher.argsPrefix, MCP_SERVER_PATH],
+                description: 'Minionry security bouncer for approving/denying Claude Code tool use',
+                env: bouncerEnv,
+            },
+            ...eligibleUserServers(workingDir, verbose, !!browserEntry),
+            ...(appToolsEntry ? { [APP_TOOLS_MCP_SERVER_NAME]: appToolsEntry } : {}),
+            ...(browserEntry ? { [BROWSER_MCP_SERVER_NAME]: browserEntry } : {}),
+            ...(qualityEntry ? { [QUALITY_MCP_SERVER_NAME]: qualityEntry } : {}),
+        };
+        const configDir = ensureMachineDir('run');
+        sweepStaleMcpConfigs(configDir);
+        const configFileName = sessionId ? `mcp-config-${sessionId}.json` : 'mcp-config.json';
+        const configPath = join(configDir, configFileName);
+        writeFileSync(configPath, JSON.stringify({ mcpServers }, null, 2));
+        if (verbose) {
+            hlog(`[${new Date().toISOString()}] Generated MCP config at ${configPath} (${Object.keys(mcpServers).length} servers)`);
+        }
+        return configPath;
+    }
+    catch (error) {
+        herror(`[${new Date().toISOString()}] Failed to generate MCP config: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/server/cli/headless/native-timeout-detector.js

@@ -0,0 +1,72 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export const NATIVE_TIMEOUT_PATTERN = /^(\w+) timed out — (continuing|retrying) with (\d+) results? preserved$/;
+export const TIMEOUT_PREFIX_PATTERN = /^[A-Z]\w* timed/;
+export class NativeTimeoutDetector {
+    lineBuffer = '';
+    detectedTimeouts = [];
+    postTimeoutBuffer = '';
+    processChunk(text) {
+        const timeouts = [];
+        let passthrough = '';
+        this.lineBuffer += text;
+        const lines = this.lineBuffer.split('\n');
+        const incomplete = lines.pop() ?? '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            const match = trimmed.match(NATIVE_TIMEOUT_PATTERN);
+            if (match) {
+                const event = {
+                    toolName: match[1],
+                    action: match[2],
+                    preservedCount: parseInt(match[3], 10),
+                };
+                timeouts.push(event);
+                this.detectedTimeouts.push(event);
+            }
+            else {
+                passthrough += `${line}\n`;
+            }
+        }
+        if (incomplete) {
+            if (TIMEOUT_PREFIX_PATTERN.test(incomplete)) {
+                this.lineBuffer = incomplete;
+            }
+            else {
+                passthrough += incomplete;
+                this.lineBuffer = '';
+            }
+        }
+        else {
+            this.lineBuffer = '';
+        }
+        if (this.detectedTimeouts.length > 0 && passthrough) {
+            this.postTimeoutBuffer += passthrough;
+            passthrough = '';
+        }
+        return { passthrough, timeouts };
+    }
+    flush() {
+        const remaining = this.lineBuffer;
+        this.lineBuffer = '';
+        if (remaining) {
+            const trimmed = remaining.trim();
+            const match = trimmed.match(NATIVE_TIMEOUT_PATTERN);
+            if (match) {
+                this.detectedTimeouts.push({
+                    toolName: match[1],
+                    action: match[2],
+                    preservedCount: parseInt(match[3], 10),
+                });
+                return '';
+            }
+        }
+        return remaining;
+    }
+    get timeoutCount() {
+        return this.detectedTimeouts.length;
+    }
+    get bufferedPostTimeoutOutput() {
+        return this.postTimeoutBuffer;
+    }
+}

package/dist/server/cli/headless/output-utils.js

@@ -0,0 +1,71 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+export function extractCleanOutput(rawOutput) {
+    const lines = rawOutput.split('\n');
+    const cleanLines = lines.filter(line => {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('{') && trimmed.includes('"type"')) {
+            return false;
+        }
+        return trimmed.length > 0;
+    });
+    return cleanLines.join('\n')
+        .replace(/\x1b\[[0-9;]*m/g, '')
+        .replace(/\r\n/g, '\n')
+        .trim();
+}
+export function estimateTokensFromOutput(output) {
+    return Math.floor(output.length / 4);
+}
+export function extractModifiedFiles(output) {
+    const filePattern = /(?:wrote|modified|created|edited)\s+(?:file\s+)?['"]?([^\s'"]+\.[a-z0-9]+)['"]?/gi;
+    const matches = output.matchAll(filePattern);
+    const files = new Set();
+    for (const match of matches) {
+        files.add(match[1]);
+    }
+    return Array.from(files);
+}
+export const ERROR_PATTERNS = [
+    { pattern: /not logged in|login required|must be authenticated|session.*expired|token.*invalid|token.*expired/i,
+        message: 'Claude Code authentication required. Please run "claude login" in your terminal to authenticate.',
+        errorCode: 'AUTH_REQUIRED' },
+    { pattern: /account.*not.*found|user.*not.*found/i,
+        message: 'Claude account not found. Please verify your account at claude.ai.',
+        errorCode: 'ACCOUNT_NOT_FOUND' },
+    { pattern: /api key|invalid key|unauthorized|forbidden.*api/i,
+        message: 'API key error. Please check your Claude Code configuration.',
+        errorCode: 'API_KEY_INVALID' },
+    { pattern: /quota exceeded|usage.*limit|billing.*issue|payment.*required|subscription.*expired/i,
+        message: 'Usage quota or subscription issue. Please check your account billing at claude.ai.',
+        errorCode: 'QUOTA_EXCEEDED' },
+    { pattern: /rate limit|too many requests|429|throttl/i,
+        message: 'Rate limit exceeded. Please wait a moment before trying again.',
+        errorCode: 'RATE_LIMITED' },
+    { pattern: /no internet|network error|connection refused|ENOTFOUND|ECONNREFUSED|ETIMEDOUT|socket hang up/i,
+        message: 'Network error. Please check your internet connection.',
+        errorCode: 'NETWORK_ERROR' },
+    { pattern: /SSL|certificate|TLS|CERT_/i,
+        message: 'SSL/TLS certificate error. Please check your network configuration.',
+        errorCode: 'SSL_ERROR' },
+    { pattern: /model not found|model unavailable|service unavailable|503|502|504/i,
+        message: 'Claude service temporarily unavailable. Please try again in a few moments.',
+        errorCode: 'SERVICE_UNAVAILABLE' },
+    { pattern: /internal server error|500/i,
+        message: 'Claude service encountered an internal error. Please try again.',
+        errorCode: 'INTERNAL_ERROR' },
+    { pattern: /context.*too.*long|context.*limit|token.*limit.*exceeded/i,
+        message: 'Context too long. Please start a new session or reduce prompt size.',
+        errorCode: 'CONTEXT_TOO_LONG' },
+    { pattern: /session.*not.*found|invalid.*session/i,
+        message: 'Session not found. Starting a new session may help.',
+        errorCode: 'SESSION_NOT_FOUND' },
+];
+export function detectErrorInStderr(stderrBuffer) {
+    for (const { pattern, message, errorCode } of ERROR_PATTERNS) {
+        if (pattern.test(stderrBuffer)) {
+            return { message, errorCode };
+        }
+    }
+    return null;
+}

package/dist/server/cli/headless/prompt-utils.js

@@ -0,0 +1,82 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { resolveClaudeCommand } from '../../engines/claude/claude-command.js';
+import { assessApproval } from './stall-assessor.js';
+export async function enrichPromptWithContext(prompt, context) {
+    let enriched = prompt;
+    const isApprovalOrContinuation = await detectApproval(prompt);
+    if (context.accumulatedKnowledge) {
+        if (isApprovalOrContinuation) {
+            enriched = `## Context from Previous Work\n${context.accumulatedKnowledge}\n\n## User Response\nThe user has responded with: "${prompt}"\n\nThis is a continuation/approval of the previous conversation. If you asked a question or requested approval in the previous movement, the user is responding to that question. Please proceed accordingly without asking the same question again.`;
+        }
+        else {
+            enriched = `## Context from Previous Work\n${context.accumulatedKnowledge}\n\n## Current Task\n${prompt}`;
+        }
+    }
+    if (context.filesModified && context.filesModified.length > 0) {
+        enriched += `\n\n## Files Modified in This Session\n${context.filesModified.join('\n')}`;
+    }
+    return enriched;
+}
+async function detectApproval(prompt) {
+    if (isApprovalPromptFast(prompt))
+        return true;
+    if (prompt.trim().length <= 100) {
+        try {
+            const claudeCmd = resolveClaudeCommand();
+            const verdict = await assessApproval(prompt, claudeCmd, false);
+            return verdict.isApproval;
+        }
+        catch {
+        }
+    }
+    return false;
+}
+export function isApprovalPrompt(prompt) {
+    return isApprovalPromptFast(prompt);
+}
+function isApprovalPromptFast(prompt) {
+    const lower = prompt.toLowerCase().trim();
+    if (['yes', 'y', 'ok', 'okay', 'sure', 'go', 'proceed', 'continue'].includes(lower)) {
+        return true;
+    }
+    const approvalPatterns = [
+        /^yes[,\s]/,
+        /^y[,\s]/,
+        /^okay[,\s]/,
+        /^ok[,\s]/,
+        /^sure[,\s]/,
+        /^go ahead/,
+        /^proceed/,
+        /^continue/,
+        /^from the (first|previous|last)/i,
+        /approval/i,
+        /approved/i
+    ];
+    return approvalPatterns.some(pattern => pattern.test(lower));
+}
+export function buildMultimodalMessage(textPrompt, imageAttachments) {
+    const content = [];
+    for (const attachment of imageAttachments) {
+        content.push({
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: attachment.mimeType || 'image/png',
+                data: attachment.content
+            }
+        });
+    }
+    content.push({
+        type: 'text',
+        text: textPrompt
+    });
+    const message = {
+        type: 'user',
+        message: {
+            role: 'user',
+            content
+        }
+    };
+    return JSON.stringify(message);
+}