@guildai/cli 0.5.7 → 0.5.9

package/dist/mcp/resources.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { GuildAPIClient } from '../lib/api-client.js';
+export declare function registerResources(server: McpServer, apiClient: GuildAPIClient, workspaceId: string): void;
+//# sourceMappingURL=resources.d.ts.map

package/dist/mcp/resources.js

@@ -0,0 +1,67 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+export function registerResources(server, apiClient, workspaceId) {
+    // guild://workspace — Current workspace info
+    server.resource('workspace', 'guild://workspace', async () => {
+        try {
+            const workspace = await apiClient.get(`/workspaces/${workspaceId}`);
+            const text = JSON.stringify({
+                id: workspace.id,
+                name: workspace.name,
+                full_name: workspace.full_name,
+            }, null, 2);
+            return {
+                contents: [
+                    {
+                        uri: 'guild://workspace',
+                        mimeType: 'application/json',
+                        text,
+                    },
+                ],
+            };
+        }
+        catch {
+            return {
+                contents: [
+                    {
+                        uri: 'guild://workspace',
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ id: workspaceId }),
+                    },
+                ],
+            };
+        }
+    });
+    // guild://agents — Agent list
+    server.resource('agents', 'guild://agents', async () => {
+        try {
+            const agents = await apiClient.fetchAll(`/workspaces/${workspaceId}/workspace_agents`);
+            const text = JSON.stringify(agents.map((a) => ({
+                id: a.id,
+                name: a.full_name || a.name,
+                description: a.description,
+            })), null, 2);
+            return {
+                contents: [
+                    {
+                        uri: 'guild://agents',
+                        mimeType: 'application/json',
+                        text,
+                    },
+                ],
+            };
+        }
+        catch {
+            return {
+                contents: [
+                    {
+                        uri: 'guild://agents',
+                        mimeType: 'application/json',
+                        text: '[]',
+                    },
+                ],
+            };
+        }
+    });
+}
+//# sourceMappingURL=resources.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,6 @@
+export interface McpServerOptions {
+    workspace?: string;
+    debug?: boolean;
+}
+export declare function startMcpServer(options: McpServerOptions): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/mcp/server.js

@@ -0,0 +1,64 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { GuildAPIClient } from '../lib/api-client.js';
+import { getAuthToken } from '../lib/auth.js';
+import { getWorkspaceId } from '../lib/guild-config.js';
+import { registerTools } from './tools.js';
+import { registerResources } from './resources.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function debugLog(debug, message) {
+    if (debug) {
+        process.stderr.write(`[guild-mcp] ${message}\n`);
+    }
+}
+export async function startMcpServer(options) {
+    const { debug = false } = options;
+    // Read version from package.json
+    const packageJson = JSON.parse(readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+    // Resolve auth token
+    const token = await getAuthToken();
+    if (!token) {
+        process.stderr.write('Error: Not authenticated. Run: guild auth login\n');
+        process.exit(1);
+    }
+    // Resolve workspace ID
+    let workspaceId = options.workspace;
+    if (!workspaceId) {
+        const resolved = await getWorkspaceId();
+        if (!resolved) {
+            process.stderr.write('Error: No workspace configured. Run: guild workspace select\n');
+            process.exit(1);
+        }
+        workspaceId = resolved.workspaceId;
+    }
+    debugLog(debug, `Starting MCP server v${packageJson.version}`);
+    debugLog(debug, `Workspace: ${workspaceId}`);
+    // Create API client
+    const apiClient = new GuildAPIClient();
+    // Create MCP server
+    const server = new McpServer({
+        name: 'guild',
+        version: packageJson.version,
+    });
+    // Register tools and resources
+    registerTools(server, apiClient, workspaceId, debug);
+    registerResources(server, apiClient, workspaceId);
+    // Create stdio transport and connect
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    debugLog(debug, 'MCP server connected via stdio');
+    // Graceful shutdown
+    const shutdown = async () => {
+        debugLog(debug, 'Shutting down MCP server');
+        await server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/tools.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { GuildAPIClient } from '../lib/api-client.js';
+export declare function registerTools(server: McpServer, apiClient: GuildAPIClient, defaultWorkspaceId: string, debug: boolean): void;
+//# sourceMappingURL=tools.d.ts.map

package/dist/mcp/tools.js

@@ -0,0 +1,803 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { z } from 'zod';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const POLL_INTERVAL_MS = 500;
+const POLL_TIMEOUT_MS = 120_000;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function debugLog(debug, message) {
+    if (debug) {
+        process.stderr.write(`[guild-mcp] ${message}\n`);
+    }
+}
+/**
+ * Poll session events until runtime_done or runtime_error.
+ * Returns collected agent messages.
+ */
+async function pollForResponse(apiClient, sessionId, debug) {
+    const startTime = Date.now();
+    const messages = [];
+    let lastEventId;
+    while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+        try {
+            const response = await apiClient.get(`/sessions/${sessionId}/events`);
+            const events = response.events || [];
+            // Find new events after last seen
+            let foundLast = !lastEventId;
+            for (const event of events) {
+                if (!foundLast) {
+                    if (event.id === lastEventId) {
+                        foundLast = true;
+                    }
+                    continue;
+                }
+                debugLog(debug, `Event: ${event.event_type}`);
+                if (event.event_type === 'agent_notification_message') {
+                    const data = extractEventText(event);
+                    if (data) {
+                        messages.push(data);
+                    }
+                }
+                if (event.event_type === 'runtime_error') {
+                    const errorText = extractEventText(event);
+                    if (errorText) {
+                        return `Error: ${errorText}`;
+                    }
+                    return 'Error: Agent encountered an error';
+                }
+                if (event.event_type === 'runtime_done') {
+                    debugLog(debug, 'Runtime done');
+                    return messages.join('\n\n') || 'Agent completed without output.';
+                }
+                lastEventId = event.id;
+            }
+            // Update lastEventId to latest
+            if (events.length > 0) {
+                lastEventId = events[events.length - 1].id;
+            }
+        }
+        catch (error) {
+            debugLog(debug, `Poll error: ${String(error)}`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+    }
+    return messages.length > 0
+        ? messages.join('\n\n') + '\n\n(Timed out waiting for completion)'
+        : 'Timed out waiting for agent response.';
+}
+function extractEventText(event) {
+    if (!event.content)
+        return undefined;
+    if (typeof event.content === 'string') {
+        return event.content;
+    }
+    if (typeof event.content === 'object' && event.content.data) {
+        return event.content.data;
+    }
+    return undefined;
+}
+function errText(action, error) {
+    return `Failed to ${action}: ${error instanceof Error ? error.message : String(error)}`;
+}
+// ---------------------------------------------------------------------------
+// Shared schema fragments
+// ---------------------------------------------------------------------------
+const workspaceIdParam = z
+    .string()
+    .optional()
+    .describe('Workspace ID (defaults to current workspace)');
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+export function registerTools(server, apiClient, defaultWorkspaceId, debug) {
+    // =========================================================================
+    // User
+    // =========================================================================
+    server.tool('guild_whoami', 'Get current user info', {}, async () => {
+        debugLog(debug, 'guild_whoami');
+        try {
+            const me = await apiClient.get('/me');
+            const text = [`Name: ${me.name}`, `ID: ${me.id}`, `Type: ${me.type}`].join('\n');
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get user info', error) }],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Workspaces
+    // =========================================================================
+    server.tool('guild_list_workspaces', 'List workspaces the current user has access to', {
+        search: z.string().optional().describe('Filter workspaces by name'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ search, limit }) => {
+        debugLog(debug, `guild_list_workspaces: search=${search || ''}`);
+        try {
+            const params = new URLSearchParams();
+            if (search)
+                params.set('search', search);
+            params.set('limit', String(limit || 20));
+            const response = await apiClient.get(`/me/workspaces?${params.toString()}`);
+            const text = response.items
+                .map((w) => `• ${w.full_name || w.name} (${w.id})`)
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No workspaces found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('list workspaces', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_workspace', 'Get workspace details including context', {
+        workspace_id: workspaceIdParam,
+    }, async ({ workspace_id }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_get_workspace: ${wsId}`);
+        try {
+            const ws = await apiClient.get(`/workspaces/${wsId}`);
+            const ownerLine = ws.owner
+                ? `Owner: ${ws.owner.name} (${ws.owner.type})`
+                : null;
+            const text = [`Name: ${ws.full_name || ws.name}`, `ID: ${ws.id}`, ownerLine]
+                .filter(Boolean)
+                .join('\n');
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get workspace', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_list_workspace_agents', 'List agents installed in a workspace', {
+        workspace_id: workspaceIdParam,
+        search: z.string().optional().describe('Filter agents by name'),
+    }, async ({ workspace_id, search }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_list_workspace_agents: ws=${wsId} search=${search || ''}`);
+        try {
+            let endpoint = `/workspaces/${wsId}/workspace_agents`;
+            if (search)
+                endpoint += `?search=${encodeURIComponent(search)}`;
+            const agents = await apiClient.fetchAll(endpoint);
+            const text = agents
+                .map((wa) => {
+                const name = wa.agent.full_name || wa.agent.name;
+                const version = wa.agent_version.version_number ||
+                    wa.agent_version.sha?.slice(0, 7) ||
+                    'latest';
+                return `• ${name} (workspace_agent: ${wa.id}, agent: ${wa.agent.id}) — v${version}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No agents in workspace.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('list workspace agents', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_add_workspace_agent', 'Install an agent in a workspace', {
+        agent_id: z.string().describe('The agent ID to install'),
+        workspace_id: workspaceIdParam,
+    }, async ({ agent_id, workspace_id }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_add_workspace_agent: ${agent_id} ws=${wsId}`);
+        try {
+            const wa = await apiClient.post(`/workspaces/${wsId}/workspace_agents`, { agent_id });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Installed agent ${wa.agent.full_name || wa.agent.name} (workspace_agent: ${wa.id})`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('add workspace agent', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_remove_workspace_agent', 'Remove an agent from the workspace', {
+        workspace_agent_id: z.string().describe('The workspace agent ID to remove'),
+    }, async ({ workspace_agent_id }) => {
+        debugLog(debug, `guild_remove_workspace_agent: ${workspace_agent_id}`);
+        try {
+            await apiClient.delete(`/workspace_agents/${workspace_agent_id}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Removed workspace agent ${workspace_agent_id}.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('remove workspace agent', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Contexts
+    // =========================================================================
+    server.tool('guild_list_contexts', 'List context versions for a workspace', {
+        workspace_id: workspaceIdParam,
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ workspace_id, limit }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_list_contexts: ws=${wsId}`);
+        try {
+            const response = await apiClient.get(`/workspaces/${wsId}/contexts?limit=${limit || 20}`);
+            const text = response.items
+                .map((c) => {
+                const summary = c.summary ? ` — ${c.summary}` : '';
+                return `• ${c.id} [${c.status}] ${c.created_at}${summary}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No contexts found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('list contexts', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_context', 'Get the content of a specific context version', {
+        context_id: z.string().describe('The context ID'),
+    }, async ({ context_id }) => {
+        debugLog(debug, `guild_get_context: ${context_id}`);
+        try {
+            const ctx = await apiClient.get(`/contexts/${context_id}`);
+            const sections = [
+                `Context: ${ctx.id}`,
+                `Status: ${ctx.status}`,
+                `Created: ${ctx.created_at}`,
+            ];
+            if (ctx.summary)
+                sections.push(`Summary: ${ctx.summary}`);
+            if (ctx.manual_context) {
+                sections.push('', '--- Manual Context ---', ctx.manual_context);
+            }
+            if (ctx.generated_context) {
+                sections.push('', '--- Generated Context ---', ctx.generated_context);
+            }
+            return { content: [{ type: 'text', text: sections.join('\n') }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get context', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_publish_context', 'Create or publish a new context version for a workspace', {
+        content: z.string().describe('The context content to publish'),
+        workspace_id: workspaceIdParam,
+        status: z
+            .enum(['ACTIVE', 'ARCHIVED'])
+            .optional()
+            .describe('Context status (default ACTIVE)'),
+        summary: z.string().optional().describe('Short summary of the context'),
+    }, async ({ content, workspace_id, status, summary }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_publish_context: ws=${wsId}`);
+        try {
+            const body = { manual_context: content };
+            if (status)
+                body.status = status;
+            if (summary)
+                body.summary = summary;
+            const ctx = await apiClient.post(`/workspaces/${wsId}/contexts`, body);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Published context ${ctx.id} [${ctx.status}]`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('publish context', error) }],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Agents (catalog)
+    // =========================================================================
+    server.tool('guild_search_agents', 'Search or list agents in the Guild catalog', {
+        search: z.string().optional().describe('Search query to filter agents by name'),
+        published_only: z
+            .boolean()
+            .optional()
+            .describe('Only show published agents (default true)'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ search, published_only, limit }) => {
+        debugLog(debug, `guild_search_agents: search=${search || ''}`);
+        try {
+            const params = new URLSearchParams();
+            if (search)
+                params.set('search', search);
+            if (published_only !== undefined)
+                params.set('published_only', String(published_only));
+            params.set('limit', String(limit || 20));
+            const response = await apiClient.get(`/agents?${params.toString()}`);
+            const text = response.items
+                .map((a) => {
+                const name = a.full_name || a.name;
+                const desc = a.description ? ` — ${a.description}` : '';
+                return `• ${name} (${a.id})${desc}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No agents found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('search agents', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_agent', 'Get details for a specific Guild agent', {
+        agent_id: z
+            .string()
+            .describe('The agent ID or full name (e.g. owner/agent-name)'),
+    }, async ({ agent_id }) => {
+        debugLog(debug, `guild_get_agent: ${agent_id}`);
+        try {
+            const agent = await apiClient.get(`/agents/${agent_id}`);
+            const lines = [
+                `Name: ${agent.full_name || agent.name}`,
+                `ID: ${agent.id}`,
+                `Status: ${agent.status}`,
+                agent.description ? `Description: ${agent.description}` : null,
+                agent.owner ? `Owner: ${agent.owner.name}` : null,
+                agent.is_public !== undefined ? `Public: ${agent.is_public}` : null,
+            ];
+            return {
+                content: [{ type: 'text', text: lines.filter(Boolean).join('\n') }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get agent', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_agent_readme', 'Get the README for a Guild agent', {
+        agent_id: z.string().describe('The agent ID or full name'),
+    }, async ({ agent_id }) => {
+        debugLog(debug, `guild_get_agent_readme: ${agent_id}`);
+        try {
+            const readme = await apiClient.get(`/agents/${agent_id}/readme`);
+            return { content: [{ type: 'text', text: readme.content }] };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('get agent readme', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_agent_code', 'Get the source code files for a Guild agent', {
+        agent_id: z.string().describe('The agent ID or full name'),
+    }, async ({ agent_id }) => {
+        debugLog(debug, `guild_get_agent_code: ${agent_id}`);
+        try {
+            const files = await apiClient.get(`/agents/${agent_id}/code`);
+            if (files.length === 0) {
+                return {
+                    content: [{ type: 'text', text: 'No source files found.' }],
+                };
+            }
+            const text = files.map((f) => `--- ${f.path} ---\n${f.content}`).join('\n\n');
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get agent code', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_list_agent_versions', 'List versions of a Guild agent', {
+        agent_id: z.string().describe('The agent ID or full name'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ agent_id, limit }) => {
+        debugLog(debug, `guild_list_agent_versions: ${agent_id}`);
+        try {
+            const response = await apiClient.get(`/agents/${agent_id}/versions?limit=${limit || 20}`);
+            const text = response.items
+                .map((v) => {
+                const version = v.version_number || v.sha?.slice(0, 7) || 'ephemeral';
+                return `• ${version} (${v.id}) [${v.status}] — ${v.summary} — ${v.created_at}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No versions found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('list agent versions', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Sessions
+    // =========================================================================
+    server.tool('guild_chat', 'Start a new chat session with a Guild agent and get a response', {
+        message: z.string().describe('The message to send to the agent'),
+        agent: z
+            .string()
+            .optional()
+            .describe('Agent identifier (e.g. owner/agent-name). Uses workspace default if not specified'),
+        workspace_id: workspaceIdParam,
+    }, async ({ message, agent, workspace_id }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_chat: message="${message}", agent=${agent || 'default'}, ws=${wsId}`);
+        try {
+            const body = {
+                session_type: 'chat',
+                initial_prompt: message,
+            };
+            if (agent) {
+                body.agent_id = agent;
+            }
+            const session = await apiClient.post(`/workspaces/${wsId}/sessions`, body);
+            debugLog(debug, `Session created: ${session.id}`);
+            const response = await pollForResponse(apiClient, session.id, debug);
+            return {
+                content: [{ type: 'text', text: response }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('chat', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_send_message', 'Send a follow-up message to an existing Guild session', {
+        session_id: z.string().describe('The session ID to send the message to'),
+        message: z.string().describe('The message to send'),
+    }, async ({ session_id, message }) => {
+        debugLog(debug, `guild_send_message: session=${session_id}`);
+        try {
+            await apiClient.post(`/sessions/${session_id}/events`, {
+                event_type: 'user_message',
+                content: { type: 'text', data: message },
+            });
+            const response = await pollForResponse(apiClient, session_id, debug);
+            return {
+                content: [{ type: 'text', text: response }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('send message', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_list_sessions', 'List recent sessions in a Guild workspace', {
+        workspace_id: workspaceIdParam,
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Number of sessions to return (default 20)'),
+    }, async ({ workspace_id, limit }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_list_sessions: ws=${wsId}`);
+        try {
+            const queryLimit = limit || 20;
+            const response = await apiClient.get(`/workspaces/${wsId}/sessions?limit=${queryLimit}`);
+            const text = response.items
+                .map((s) => `• ${s.id} (${s.session_type}) — ${s.created_at}`)
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No sessions found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('list sessions', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_session', 'Get session details and recent events from a Guild session', {
+        session_id: z.string().describe('The session ID'),
+    }, async ({ session_id }) => {
+        debugLog(debug, `guild_get_session: ${session_id}`);
+        try {
+            const [session, eventsResponse] = await Promise.all([
+                apiClient.get(`/sessions/${session_id}`),
+                apiClient.get(`/sessions/${session_id}/events`),
+            ]);
+            const events = eventsResponse.events || [];
+            const recentEvents = events.slice(-20);
+            const eventLines = recentEvents.map((e) => {
+                const text = extractEventText(e);
+                const preview = text
+                    ? `: ${text.slice(0, 100)}${text.length > 100 ? '...' : ''}`
+                    : '';
+                return `  [${e.event_type}]${preview}`;
+            });
+            const text = [
+                `Session: ${session.id}`,
+                `Type: ${session.session_type}`,
+                `Created: ${session.created_at}`,
+                `Updated: ${session.updated_at}`,
+                '',
+                `Recent events (${recentEvents.length} of ${events.length}):`,
+                ...eventLines,
+            ].join('\n');
+            return {
+                content: [{ type: 'text', text }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('get session', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_session_events', 'Get events from a Guild session with pagination', {
+        session_id: z.string().describe('The session ID'),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(200)
+            .optional()
+            .describe('Max events to return (default 50)'),
+    }, async ({ session_id, limit }) => {
+        debugLog(debug, `guild_get_session_events: ${session_id}`);
+        try {
+            const response = await apiClient.get(`/sessions/${session_id}/events`);
+            const events = response.events || [];
+            const maxEvents = limit || 50;
+            const displayed = events.slice(-maxEvents);
+            const lines = displayed.map((e) => {
+                const text = extractEventText(e);
+                const preview = text
+                    ? `: ${text.slice(0, 200)}${text.length > 200 ? '...' : ''}`
+                    : '';
+                return `[${e.created_at}] ${e.event_type}${preview}`;
+            });
+            const header = `Events (${displayed.length} of ${events.length}):`;
+            return {
+                content: [{ type: 'text', text: [header, ...lines].join('\n') }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('get session events', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_interrupt_session', 'Interrupt a running Guild session', {
+        session_id: z.string().describe('The session ID to interrupt'),
+    }, async ({ session_id }) => {
+        debugLog(debug, `guild_interrupt_session: ${session_id}`);
+        try {
+            await apiClient.post(`/sessions/${session_id}/interrupt`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Interrupted session ${session_id}.`,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('interrupt session', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Triggers
+    // =========================================================================
+    server.tool('guild_list_triggers', 'List triggers configured in a workspace', {
+        workspace_id: workspaceIdParam,
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ workspace_id, limit }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_list_triggers: ws=${wsId}`);
+        try {
+            const response = await apiClient.get(`/workspaces/${wsId}/triggers?limit=${limit || 20}`);
+            const text = response.items
+                .map((t) => {
+                const agent = t.agent.full_name || t.agent.name;
+                const disabled = t.deactivated_at ? ' [DISABLED]' : '';
+                if (t.type === 'webhook') {
+                    return `• ${t.id} [webhook] ${t.service}/${t.event_type || '*'} → ${agent}${disabled}`;
+                }
+                return `• ${t.id} [time] ${t.frequency} → ${agent}${disabled}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No triggers found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: errText('list triggers', error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_get_trigger_sessions', 'List sessions spawned by a specific trigger', {
+        trigger_id: z.string().describe('The trigger ID'),
+        workspace_id: workspaceIdParam,
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe('Max results (default 20)'),
+    }, async ({ trigger_id, workspace_id, limit }) => {
+        const wsId = workspace_id || defaultWorkspaceId;
+        debugLog(debug, `guild_get_trigger_sessions: ${trigger_id} ws=${wsId}`);
+        try {
+            const response = await apiClient.get(`/workspaces/${wsId}/sessions?trigger_id=${trigger_id}&limit=${limit || 20}`);
+            const text = response.items
+                .map((s) => `• ${s.id} (${s.session_type}) — ${s.created_at}`)
+                .join('\n');
+            return {
+                content: [
+                    { type: 'text', text: text || 'No trigger sessions found.' },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('get trigger sessions', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // =========================================================================
+    // Credentials / Integrations
+    // =========================================================================
+    server.tool('guild_list_credentials', 'List connected integration credentials', {}, async () => {
+        debugLog(debug, 'guild_list_credentials');
+        try {
+            const me = await apiClient.get('/me');
+            const response = await apiClient.get(`/credentials?account_id=${me.id}`);
+            const text = response.items
+                .map((c) => {
+                const status = c.status ? ` [${c.status}]` : '';
+                return `• ${c.service} (${c.id})${status}`;
+            })
+                .join('\n');
+            return {
+                content: [{ type: 'text', text: text || 'No credentials found.' }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    { type: 'text', text: errText('list credentials', error) },
+                ],
+                isError: true,
+            };
+        }
+    });
+    server.tool('guild_list_available_integrations', 'List available integrations that can be connected', {}, async () => {
+        debugLog(debug, 'guild_list_available_integrations');
+        try {
+            const integrations = await apiClient.get('/credentials/available');
+            const items = Array.isArray(integrations) ? integrations : [];
+            const text = items
+                .map((i) => {
+                const desc = i.description ? ` — ${i.description}` : '';
+                return `• ${i.name || i.service} (${i.service})${desc}`;
+            })
+                .join('\n');
+            return {
+                content: [
+                    { type: 'text', text: text || 'No integrations available.' },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: errText('list available integrations', error),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=tools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guildai/cli",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Guild.ai CLI - Build, test, and deploy AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -18,6 +18,8 @@
     "dist/components/**/*.d.ts",
     "dist/lib/**/*.js",
     "dist/lib/**/*.d.ts",
+    "dist/mcp/**/*.js",
+    "dist/mcp/**/*.d.ts",
     "dist/assets/",
     "docs/"
   ],