@genspark/cli 1.0.9 → 1.0.11

package/README.md

@@ -463,9 +463,35 @@ gsk task cross_check --task_name "Earth shape" --query "The Earth is flat" --ins
 | `--task_name <name>` | — | Name for the task (**required**) |
 | `--query <text>` | — | Query describing what to create (**required**) |
 | `--instructions <text>` | — | Detailed instructions (**required**) |
+| `--acp` | `false` | Start as ACP (Agent Client Protocol) stdio agent for multi-turn use with Genspark Claw |
 
 **Supported task types:** `super_agent`, `podcasts`, `docs`, `slides`, `sheets`, `deep_research`, `website`, `video_generation`, `audio_generation`, `meeting_notes`, `cross_check`
 
+#### ACP Mode
+
+Use `--acp` to start a task agent as an [Agent Client Protocol](https://agentclientprotocol.com/) stdio server. This enables AI agent platforms like [Genspark Claw](https://openclaw.ai) to natively discover and interact with GSK agents, with multi-turn conversation support.
+
+```bash
+# Start an ACP agent for slides (used by acpx, not typically run manually)
+gsk task slides --acp
+
+# Start an ACP agent for documents
+gsk task docs --acp
+```
+
+**acpx configuration** (`~/.acpx/config.json`):
+```json
+{
+  "agents": {
+    "gsk-slides": { "command": "gsk task slides --acp" },
+    "gsk-docs":   { "command": "gsk task docs --acp" },
+    "gsk-sheets": { "command": "gsk task sheets --acp" }
+  }
+}
+```
+
+Then in Genspark Claw: `/acp spawn gsk-slides` to create and iterate on presentations via natural language.
+
 ### Stock Prices
 
 ### stock_price (alias: `stock`)
@@ -662,19 +688,19 @@ gsk calendar create --summary "Personal Event" --start_time "..." --end_time "..
 
 ### AI Phone Calls
 
-### call
+### phone-call (alias: `call-for-me`)
 
 Make an AI phone call on your behalf. The AI validates prerequisites, resolves contact info, and initiates the call.
 
 ```bash
 # Call a business by phone number
-gsk call "Pizza Hut" -c "+1-555-123-4567" -p "Check if they deliver to my area"
+gsk phone-call "Pizza Hut" -c "+1-555-123-4567" -p "Check if they deliver to my area"
 
 # Call a business by Google Maps place_id
-gsk call "Joe's Pizza" -c "ChIJxxxxxxxx" --is_place_id -p "Reserve a table for 4"
+gsk phone-call "Joe's Pizza" -c "ChIJxxxxxxxx" --is_place_id -p "Reserve a table for 4"
 
 # Dry run: validate and resolve contact info without initiating the call
-gsk call "Pizza Hut" -c "+1-555-123-4567" -p "Check hours" --dry-run
+gsk phone-call "Pizza Hut" -c "+1-555-123-4567" -p "Check hours" --dry-run
 ```
 
 | Option | Default | Description |

package/dist/acp-serve.d.ts

@@ -0,0 +1,23 @@
+/**
+ * ACP (Agent Client Protocol) stdio bridge for GSK task agents.
+ *
+ * Speaks ACP JSON-RPC over stdin/stdout, internally calls GSK backend APIs.
+ * Usage: gsk task <type> --acp
+ *
+ * Protocol: NDJSON (one JSON-RPC 2.0 message per line on stdin/stdout)
+ */
+import type { GlobalOptions } from './types.js';
+export interface PersistedSession {
+    sessionId: string;
+    taskType: string;
+    projectId: string;
+    createdAt: string;
+}
+export declare function getSessionStorePath(): string;
+export declare function sanitizeId(id: string): string;
+export declare function loadPersistedSession(sessionId: string): PersistedSession | null;
+/**
+ * Start the ACP stdio bridge for a given task type.
+ */
+export declare function startAcpBridge(taskType: string, globalOpts: GlobalOptions): Promise<void>;
+//# sourceMappingURL=acp-serve.d.ts.map

package/dist/acp-serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acp-serve.d.ts","sourceRoot":"","sources":["../src/acp-serve.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,YAAY,CAAA;AAkC5D,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAU5C;AAGD,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE7C;AAiBD,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAU/E;AAwBD;;GAEG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,IAAI,CAAC,CAmgBf"}

package/dist/acp-serve.js

@@ -0,0 +1,603 @@
+/**
+ * ACP (Agent Client Protocol) stdio bridge for GSK task agents.
+ *
+ * Speaks ACP JSON-RPC over stdin/stdout, internally calls GSK backend APIs.
+ * Usage: gsk task <type> --acp
+ *
+ * Protocol: NDJSON (one JSON-RPC 2.0 message per line on stdin/stdout)
+ */
+import { ApiClient } from './client.js';
+import { debug } from './logger.js';
+import * as readline from 'readline';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as pathModule from 'path';
+function isRequest(msg) {
+    return 'id' in msg;
+}
+export function getSessionStorePath() {
+    const dir = pathModule.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.genspark-tool-cli', 'acp-sessions');
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+// Sanitize session ID to prevent path traversal
+export function sanitizeId(id) {
+    return id.replace(/[^a-zA-Z0-9_-]/g, '');
+}
+function persistSession(session) {
+    if (!session.projectId)
+        return;
+    const data = {
+        sessionId: session.sessionId,
+        taskType: session.taskType,
+        projectId: session.projectId,
+        createdAt: new Date().toISOString(),
+    };
+    const filePath = pathModule.join(getSessionStorePath(), `${sanitizeId(session.sessionId)}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(data));
+}
+export function loadPersistedSession(sessionId) {
+    const safe = sanitizeId(sessionId);
+    if (!safe)
+        return null;
+    const filePath = pathModule.join(getSessionStorePath(), `${safe}.json`);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function listPersistedSessions(taskType) {
+    const dir = getSessionStorePath();
+    const sessions = [];
+    if (!fs.existsSync(dir))
+        return sessions;
+    for (const file of fs.readdirSync(dir)) {
+        if (!file.endsWith('.json'))
+            continue;
+        try {
+            const data = JSON.parse(fs.readFileSync(pathModule.join(dir, file), 'utf-8'));
+            if (!taskType || data.taskType === taskType) {
+                sessions.push(data);
+            }
+        }
+        catch {
+            // skip corrupted files
+        }
+    }
+    return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+/**
+ * Start the ACP stdio bridge for a given task type.
+ */
+export async function startAcpBridge(taskType, globalOpts) {
+    const client = new ApiClient(globalOpts);
+    const session = {
+        sessionId: crypto.randomUUID(),
+        taskType,
+        projectId: null,
+    };
+    let promptInFlight = false;
+    let stdinClosed = false;
+    let currentAbortController = null;
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+    function send(obj) {
+        const line = JSON.stringify({ jsonrpc: '2.0', ...obj });
+        process.stdout.write(line + '\n');
+    }
+    function sendResponse(id, result) {
+        send({ id, result });
+    }
+    function sendError(id, code, message) {
+        send({ id, error: { code, message } });
+    }
+    function sendNotification(method, params) {
+        send({ method, params });
+    }
+    function sendAgentMessage(sessionId, text) {
+        sendNotification('session/update', {
+            sessionId,
+            update: {
+                sessionUpdate: 'agent_message_chunk',
+                content: { type: 'text', text },
+            },
+        });
+    }
+    function sendToolCall(sessionId, toolCallId, title, status) {
+        sendNotification('session/update', {
+            sessionId,
+            update: {
+                sessionUpdate: 'tool_call',
+                toolCallId,
+                title,
+                kind: 'other',
+                status,
+            },
+        });
+    }
+    function sendToolCallUpdate(sessionId, toolCallId, status, content) {
+        const update = {
+            sessionUpdate: 'tool_call_update',
+            toolCallId,
+            status,
+        };
+        if (content) {
+            update.content = [
+                { type: 'content', content: { type: 'text', text: content } },
+            ];
+        }
+        sendNotification('session/update', { sessionId, update });
+    }
+    // --- Handler: initialize ---
+    async function handleInitialize(msg) {
+        sendResponse(msg.id, {
+            protocolVersion: 1,
+            agentCapabilities: {
+                loadSession: true,
+                sessionCapabilities: { list: true },
+                promptCapabilities: {},
+            },
+            agentInfo: {
+                name: `gsk-${taskType}`,
+                title: `Genspark ${taskType.charAt(0).toUpperCase() + taskType.slice(1)} Agent`,
+                version: '1.0.0',
+            },
+            authMethods: [],
+        });
+    }
+    // --- Handler: session/new ---
+    async function handleSessionNew(msg) {
+        if (promptInFlight) {
+            sendError(msg.id, -32603, 'Cannot create new session while a prompt is in progress');
+            return;
+        }
+        session.sessionId = crypto.randomUUID();
+        session.projectId = null;
+        sendResponse(msg.id, {
+            sessionId: session.sessionId,
+            configOptions: [],
+            modes: {
+                currentModeId: 'default',
+                availableModes: [
+                    {
+                        id: 'default',
+                        name: 'Default',
+                        description: `Create and iterate on ${taskType}`,
+                    },
+                ],
+            },
+        });
+    }
+    // --- Handler: session/load ---
+    async function handleSessionLoad(msg) {
+        if (promptInFlight) {
+            sendError(msg.id, -32603, 'Cannot load session while a prompt is in progress');
+            return;
+        }
+        const params = msg.params || {};
+        const targetSessionId = params.sessionId;
+        if (!targetSessionId) {
+            sendError(msg.id, -32602, 'sessionId is required');
+            return;
+        }
+        const persisted = loadPersistedSession(targetSessionId);
+        if (!persisted) {
+            sendError(msg.id, -32002, `Session not found: ${targetSessionId}`);
+            return;
+        }
+        // Validate task type matches this bridge's type
+        if (persisted.taskType !== taskType) {
+            sendError(msg.id, -32602, `Task type mismatch: session is ${persisted.taskType}, but this bridge is ${taskType}`);
+            return;
+        }
+        // Restore session state
+        session.sessionId = persisted.sessionId;
+        session.projectId = persisted.projectId;
+        // Check if there's an in-progress agent and reconnect to its event stream.
+        // This must complete BEFORE sending the session/load response, otherwise
+        // the caller may send session/prompt while promptInFlight is still true,
+        // causing a "A prompt is already in progress" race condition.
+        if (session.projectId) {
+            promptInFlight = true;
+            currentAbortController = new AbortController();
+            try {
+                const eventsResult = await client.agentAskEvents(session.projectId, session.taskType, undefined, currentAbortController.signal);
+                if (eventsResult.status === 'ok') {
+                    const data = eventsResult.data;
+                    const text = extractResponseText(data);
+                    if (text && text !== '{}') {
+                        // Intentional: this notification is sent before the session/load
+                        // response below. JSON-RPC allows notifications at any time and
+                        // they carry sessionId for correlation. The response must come
+                        // after the probe so the caller doesn't race with session/prompt.
+                        sendAgentMessage(session.sessionId, text);
+                    }
+                    if (eventsResult.message === 'no_running_agent') {
+                        debug('[ACP] Agent finished, replayed last result');
+                    }
+                    else {
+                        debug('[ACP] Reconnected to in-progress agent and got result');
+                    }
+                }
+                else {
+                    debug('[ACP] No in-progress agent, session ready for new prompts');
+                }
+            }
+            catch {
+                debug('[ACP] Failed to check for in-progress agent, continuing');
+            }
+            finally {
+                promptInFlight = false;
+                currentAbortController = null;
+            }
+        }
+        // Send response AFTER reconnect probe completes, so the caller knows
+        // it's safe to send session/prompt without hitting promptInFlight guard.
+        sendResponse(msg.id, {
+            sessionId: session.sessionId,
+            configOptions: [],
+            modes: {
+                currentModeId: 'default',
+                availableModes: [
+                    {
+                        id: 'default',
+                        name: 'Default',
+                        description: `Create and iterate on ${taskType}`,
+                    },
+                ],
+            },
+        });
+        if (stdinClosed)
+            process.exit(0);
+    }
+    // --- Handler: session/list ---
+    async function handleSessionList(msg) {
+        const sessions = listPersistedSessions(taskType);
+        sendResponse(msg.id, sessions.map(s => ({
+            sessionId: s.sessionId,
+            taskType: s.taskType,
+            projectId: s.projectId,
+            createdAt: s.createdAt,
+        })));
+    }
+    // --- Handler: session/prompt ---
+    async function handleSessionPrompt(msg) {
+        const params = msg.params || {};
+        const promptParts = params.prompt;
+        const text = promptParts
+            ?.filter(p => p.type === 'text' && p.text)
+            .map(p => p.text)
+            .join('\n') || '';
+        const useModel = params.use_model || undefined;
+        // Reject concurrent prompts — ACP processes one prompt at a time
+        if (promptInFlight) {
+            sendError(msg.id, -32603, 'A prompt is already in progress');
+            return;
+        }
+        if (!text) {
+            sendError(msg.id, -32602, 'Empty prompt');
+            return;
+        }
+        promptInFlight = true;
+        currentAbortController = new AbortController();
+        const toolCallId = `task-${Date.now()}`;
+        const activeAgentToolCalls = [];
+        try {
+            // Announce tool call for progress visibility
+            sendToolCall(session.sessionId, toolCallId, `Processing ${taskType} request`, 'pending');
+            let streamedContent = '';
+            const responseText = await askAgent(client, session, text, currentAbortController.signal, progressMsg => {
+                sendToolCallUpdate(session.sessionId, toolCallId, 'in_progress', progressMsg);
+            }, 
+            // Stream deltas as agent_message_chunk in real-time
+            delta => {
+                sendAgentMessage(session.sessionId, delta);
+                streamedContent += delta;
+            }, 
+            // Show agent's internal tool calls as ACP tool_call notifications
+            (tcId, tcName) => {
+                // Mark previous agent tool calls as completed
+                for (const prevId of activeAgentToolCalls) {
+                    sendToolCallUpdate(session.sessionId, prevId, 'completed');
+                }
+                activeAgentToolCalls.length = 0;
+                // Start new tool call
+                sendToolCall(session.sessionId, tcId, tcName, 'in_progress');
+                activeAgentToolCalls.push(tcId);
+                // Also emit as text delta so the tool name is visible in the
+                // OpenClaw web UI.  The gateway's ACP event callback only
+                // forwards text_delta events, so tool_call notifications are
+                // invisible to WS clients without this.
+                sendAgentMessage(session.sessionId, `\nUsing Tool: ${tcName}\n`);
+            }, useModel, 
+            // Persist session as soon as project_id is available so
+            // session/load works even if the stream disconnects mid-flight
+            () => {
+                persistSession(session);
+            });
+            // Mark remaining agent tool calls as completed
+            for (const prevId of activeAgentToolCalls) {
+                sendToolCallUpdate(session.sessionId, prevId, 'completed');
+            }
+            // Mark top-level tool call completed
+            sendToolCallUpdate(session.sessionId, toolCallId, 'completed');
+            // Persist session for future session/load
+            persistSession(session);
+            // Send final response only if it differs from what was streamed
+            // (e.g., content was replaced by message_result after deltas),
+            // or if nothing was streamed at all.
+            if (responseText && responseText !== streamedContent) {
+                sendAgentMessage(session.sessionId, responseText);
+            }
+            // Complete the prompt
+            sendResponse(msg.id, { stopReason: 'end_turn' });
+        }
+        catch (err) {
+            // Clean up any in-progress agent tool calls
+            for (const prevId of activeAgentToolCalls) {
+                sendToolCallUpdate(session.sessionId, prevId, 'completed');
+            }
+            if (err.name === 'AbortError') {
+                sendToolCallUpdate(session.sessionId, toolCallId, 'completed', 'Cancelled');
+                sendResponse(msg.id, { stopReason: 'cancelled' });
+            }
+            else {
+                sendToolCallUpdate(session.sessionId, toolCallId, 'completed', 'Error');
+                sendAgentMessage(session.sessionId, `Error: ${err.message}`);
+                sendResponse(msg.id, { stopReason: 'end_turn' });
+            }
+        }
+        finally {
+            // Ensure session is persisted even on error/cancellation, as long
+            // as we captured a project_id mid-stream.  Wrapped in try-catch so
+            // a disk-full / permission error doesn't prevent the critical state
+            // reset below (which would permanently lock the bridge).
+            try {
+                persistSession(session);
+            }
+            catch (e) {
+                debug(`[ACP] Failed to persist session: ${e.message}`);
+            }
+            promptInFlight = false;
+            currentAbortController = null;
+            if (stdinClosed)
+                process.exit(0);
+        }
+    }
+    // --- Handler: session/cancel ---
+    function handleSessionCancel() {
+        if (currentAbortController) {
+            currentAbortController.abort();
+            debug('[ACP] session/cancel: aborting in-flight request');
+        }
+    }
+    // --- Handler: session/export ---
+    async function handleSessionExport(msg) {
+        if (!session.projectId) {
+            sendError(msg.id, -32603, 'No active project to export. Send a prompt first.');
+            return;
+        }
+        const params = msg.params || {};
+        const format = params.format || 'auto';
+        const outputPath = params.outputPath;
+        debug(`[ACP] session/export: format=${format}, outputPath=${outputPath || '(none)'}`);
+        try {
+            const result = await client.exportArtifact(session.projectId, session.taskType, format);
+            if (result.status !== 'ok' || !result.data) {
+                sendError(msg.id, -32603, `Export failed: ${result.message || 'unknown error'}`);
+                return;
+            }
+            const data = result.data;
+            const downloadUrl = data.download_url;
+            const fileName = data.file_name;
+            const exportFormat = data.format;
+            const responseData = {
+                download_url: downloadUrl,
+                file_name: fileName,
+                format: exportFormat,
+            };
+            // If outputPath specified, download to local file
+            if (outputPath && downloadUrl) {
+                try {
+                    const resp = await fetch(downloadUrl);
+                    if (resp.ok) {
+                        const buffer = Buffer.from(await resp.arrayBuffer());
+                        fs.writeFileSync(outputPath, buffer);
+                        responseData.local_path = pathModule.resolve(outputPath);
+                        responseData.size_bytes = buffer.length;
+                        debug(`[ACP] Exported ${buffer.length} bytes → ${outputPath}`);
+                    }
+                    else {
+                        responseData.download_error = `HTTP ${resp.status}`;
+                    }
+                }
+                catch (dlErr) {
+                    responseData.download_error = dlErr.message;
+                }
+            }
+            sendResponse(msg.id, responseData);
+        }
+        catch (err) {
+            sendError(msg.id, -32603, `Export error: ${err.message}`);
+        }
+    }
+    // --- Message router ---
+    rl.on('line', async (line) => {
+        if (!line.trim())
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (msg.jsonrpc !== '2.0')
+            return;
+        const method = msg.method;
+        debug(`[ACP] Received: ${method}`);
+        try {
+            switch (method) {
+                case 'initialize':
+                    if (isRequest(msg))
+                        await handleInitialize(msg);
+                    break;
+                case 'session/new':
+                    if (isRequest(msg))
+                        await handleSessionNew(msg);
+                    break;
+                case 'session/load':
+                    if (isRequest(msg))
+                        await handleSessionLoad(msg);
+                    break;
+                case 'session/list':
+                    if (isRequest(msg))
+                        await handleSessionList(msg);
+                    break;
+                case 'session/prompt':
+                    if (isRequest(msg))
+                        await handleSessionPrompt(msg);
+                    break;
+                case 'session/export':
+                    if (isRequest(msg))
+                        await handleSessionExport(msg);
+                    break;
+                case 'session/cancel':
+                    handleSessionCancel();
+                    break;
+                default:
+                    if (isRequest(msg)) {
+                        sendError(msg.id, -32601, `Method not found: ${method}`);
+                    }
+            }
+        }
+        catch (err) {
+            if (isRequest(msg)) {
+                sendError(msg.id, -32603, err.message);
+            }
+        }
+    });
+    rl.on('close', () => {
+        stdinClosed = true;
+        if (!promptInFlight)
+            process.exit(0);
+    });
+}
+/**
+ * Send a message to the agent via agent_ask endpoint (streaming).
+ * First call (no projectId) creates the project; subsequent calls continue it.
+ */
+async function askAgent(client, session, message, signal, onProgress, onDelta, onToolCall, useModel, onProjectId) {
+    const result = await client.agentAsk(session.projectId, message, session.taskType, msg => {
+        // Capture project_id from intermediate stream message as early as
+        // possible so the session can be persisted before the stream ends.
+        if (msg.project_id && !session.projectId) {
+            session.projectId = msg.project_id;
+            debug(`[ACP] Project created (mid-stream): ${session.projectId}`);
+            if (onProjectId)
+                onProjectId();
+        }
+        if (msg.delta && onDelta) {
+            onDelta(msg.delta);
+        }
+        else if (msg.tool_call_name && onToolCall) {
+            onToolCall(msg.tool_call_id || `agent-tool-${Date.now()}`, msg.tool_call_name);
+        }
+        else if (msg.heartbeat) {
+            onProgress(`Processing... (${msg.elapsed_seconds}s)`);
+        }
+    }, signal, useModel);
+    if (result.status !== 'ok' || !result.data) {
+        throw new Error(result.message || 'agent_ask failed');
+    }
+    const data = result.data;
+    // Extract project_id from final result as fallback (in case the
+    // intermediate project_id message was not received, e.g. older server)
+    const projectId = data.project_id;
+    if (projectId && !session.projectId) {
+        session.projectId = projectId;
+        debug(`[ACP] Project created (final result): ${session.projectId}`);
+    }
+    return extractResponseText(data);
+}
+/**
+ * Extract human-readable response text from task result.
+ * Handles artifact URLs for various task types:
+ * - docs/slides/sheets: file_url + optional file_name
+ * - podcasts: file_url (audio) + video_file_url
+ * - image/video/audio generation: results[] array with URLs
+ */
+function extractResponseText(data) {
+    const resultContent = data.result_content;
+    if (resultContent) {
+        const lastMessage = resultContent.last_message;
+        const parts = lastMessage && lastMessage.length > 0 ? [...lastMessage] : [];
+        // Artifacts are nested under result_content.artifacts
+        const artifacts = resultContent.artifacts;
+        if (artifacts) {
+            // Single file artifact (docs, slides, sheets, podcasts audio)
+            const fileUrl = artifacts.file_url;
+            if (fileUrl) {
+                const fileName = artifacts.file_name;
+                parts.push(fileName ? `\nFile: ${fileUrl} (${fileName})` : `\nFile: ${fileUrl}`);
+            }
+            // Podcasts video
+            const videoFileUrl = artifacts.video_file_url;
+            if (videoFileUrl) {
+                parts.push(`Video: ${videoFileUrl}`);
+            }
+            // Media generation results (image/video/audio arrays)
+            const results = artifacts.results;
+            if (results && results.length > 0) {
+                parts.push(''); // blank line separator
+                for (const item of results) {
+                    const url = (item.image_url ||
+                        item.video_url ||
+                        item.audio_url ||
+                        item.url);
+                    const prompt = item.prompt;
+                    if (url) {
+                        parts.push(prompt ? `- ${url} (${prompt})` : `- ${url}`);
+                    }
+                }
+            }
+            // Append any remaining artifact fields as JSON
+            const knownKeys = new Set([
+                'file_url',
+                'file_name',
+                'video_file_url',
+                'results',
+            ]);
+            const extra = {};
+            for (const [k, v] of Object.entries(artifacts)) {
+                if (!knownKeys.has(k) && v)
+                    extra[k] = v;
+            }
+            if (Object.keys(extra).length > 0) {
+                parts.push(`\n${JSON.stringify(extra)}`);
+            }
+        }
+        // Artifacts note (project URL etc.)
+        const artifactsNote = resultContent.artifacts_note;
+        if (artifactsNote) {
+            parts.push(`\n${artifactsNote}`);
+        }
+        if (parts.length > 0) {
+            return parts.join('\n');
+        }
+    }
+    const msg = data.message;
+    if (msg)
+        return msg;
+    // Don't expose raw JSON to the user
+    return '';
+}
+//# sourceMappingURL=acp-serve.js.map