@guildai/cli 0.7.0 → 0.8.0

package/dist/commands/agent/unpublish.js

@@ -9,7 +9,7 @@ export function createAgentUnpublishCommand() {
     const cmd = new Command('unpublish');
     cmd
         .description('Unpublish the latest published version of an agent')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner/agent-name)')
+        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
         .action(async (agentIdArg) => {
         const output = createOutputWriter();
         try {

package/dist/commands/agent/update.js

@@ -26,7 +26,7 @@ export function createAgentUpdateCommand() {
     const cmd = new Command('update');
     cmd
         .description('Update agent properties (visibility)')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner/agent-name)')
+        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
         .option('--public', 'Make the agent public (visible to everyone)')
         .option('--private', 'Make the agent private (only visible to owner)')
         .option('--yes', 'Skip confirmation prompt for visibility changes')

package/dist/commands/agent/versions.js

@@ -11,7 +11,7 @@ export function createAgentVersionsCommand() {
     const cmd = new Command('versions');
     cmd
         .description('List all versions of an agent')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner/agent-name)')
+        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
         .option('--limit <number>', 'Maximum number of versions to return', '20')
         .option('--offset <number>', 'Number of versions to skip', '0')
         .action(async (agentIdArg, options) => {

package/dist/commands/agent/workspaces.js

@@ -11,7 +11,7 @@ export function createAgentWorkspacesCommand() {
     const cmd = new Command('workspaces');
     cmd
         .description('List workspaces that use an agent')
-        .argument('[identifier]', 'Agent ID or full name (e.g., owner/agent-name)')
+        .argument('[identifier]', 'Agent ID or full name (e.g., owner~agent-name)')
         .option('--limit <number>', 'Maximum number of workspaces to return', '20')
         .option('--offset <number>', 'Number of workspaces to skip', '0')
         .action(async (agentIdArg, options) => {

package/dist/commands/chat.js

@@ -13,7 +13,7 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, matchesAgent, getAgentName, } from '../lib/session-events.js';
+import { isUnfulfilledAgentInstallRequest, isFilteredTaskName, getTaskDisplayName, getAgentName, } from '../lib/session-events.js';
 import { printResumeHint, fetchSession, fetchSessionEvents, eventsToDisplayMessages, } from '../lib/session-resume.js';
 import { DEFAULT_EVENT_TYPES, parseEventFilter, shouldShowEvent, } from '../lib/event-filter.js';
 import { fetchEvents, fetchTasks } from '../lib/session-events-fetch.js';
@@ -1087,24 +1087,37 @@ export function createChatCommand() {
                     else {
                         inactivityCounter++;
                     }
-                    // Check if we got a completion response
-                    // Look for runtime_done events from the ROOT task (the agent we're chatting with)
-                    // For orchestrating agents like agent-builder that spawn child tasks, we need to
-                    // wait for the root agent's completion, not just any runtime_done event.
-                    const targetAgent = options.agent || 'assistant';
-                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id // Root task has no parent
-                    );
-                    // Also check for agent_notification_message events from the root agent
-                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
-                        matchesAgent(e.task?.agent, targetAgent) &&
-                        !e.task?.parent_task_id);
+                    const isRootTask = (e) => !e.task?.parent_task;
+                    const hasRootTaskDone = allEvents.some((e) => e.type === 'runtime_done' && isRootTask(e));
+                    const hasAgentMessage = allEvents.some((e) => e.type === 'agent_notification_message' && isRootTask(e));
+                    const hasRootTaskError = allEvents.some((e) => e.type === 'runtime_error' && isRootTask(e));
                     // Check for a ui_prompt request... that ends the game.
                     const hasUIPromptMessage = allEvents.some((e) => e.type === 'agent_notification_message' &&
                         e.task?.tool_name === 'ui_prompt');
+                    if (hasRootTaskError) {
+                        debug('Found error event from root agent, exiting --once mode');
+                        const errorEvents = allEvents.filter((e) => e.type === 'runtime_error' || e.type === 'agent_notification_error');
+                        if (errorEvents.length > 0 && !options.mode) {
+                            const lastError = errorEvents[errorEvents.length - 1];
+                            const content = lastError.content;
+                            if (content?.data) {
+                                console.error(chalk.red(`Error: ${content.data}`));
+                            }
+                            else {
+                                console.error(chalk.red('Agent failed to start'));
+                            }
+                        }
+                        else if (options.mode === 'json') {
+                            console.log(JSON.stringify({
+                                session_id: session.id,
+                                events: allEvents,
+                                error: true,
+                            }, null, 2));
+                        }
+                        process.exit(1);
+                    }
                     if (hasRootTaskDone || hasAgentMessage || hasUIPromptMessage) {
-                        debug(`Found completion event from root agent (${targetAgent}), exiting --once mode`);
+                        debug('Found completion event from root agent, exiting --once mode');
                         await outputOnceResult(session.id, allEvents, options.mode);
                         process.exit(0);
                     }

package/dist/commands/config/list.js

@@ -27,13 +27,13 @@ export function createConfigListCommand() {
             output.progress(chalk.dim('  guild workspace select'));
             return;
         }
-        if (hasGlobal) {
+        if (config.global && hasGlobal) {
             output.progress(chalk.bold('Global config') + chalk.dim(' (~/.guild/config.json):'));
             for (const [key, value] of Object.entries(config.global)) {
                 output.progress(`  ${key}: ${chalk.cyan(String(value))}`);
             }
         }
-        if (hasLocal) {
+        if (config.local && hasLocal) {
             if (hasGlobal)
                 output.progress('');
             output.progress(chalk.bold('Local config') + chalk.dim(' (guild.json):'));

package/dist/commands/integration/operation/create.js

@@ -17,7 +17,7 @@ export function createIntegrationOperationCreateCommand() {
     cmd
         .description('Create operation(s) for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--operation <name>', 'Operation identifier, e.g. list_users')
         .option('--method <method>', 'HTTP method: GET, POST, PUT, PATCH, DELETE')
         .option('--path <path>', 'REST path, e.g. /{owner}/{repo}/issues')
@@ -35,7 +35,7 @@ export function createIntegrationOperationCreateCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.openapi) {
                 // OpenAPI mode
                 if (!existsSync(options.openapi)) {

package/dist/commands/integration/operation/list.js

@@ -14,7 +14,7 @@ export function createIntegrationOperationListCommand() {
     cmd
         .description('List operations for an integration version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (identifier, options) => {
@@ -26,7 +26,7 @@ export function createIntegrationOperationListCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);

package/dist/commands/integration/update.js

@@ -63,7 +63,7 @@ export function createIntegrationUpdateCommand() {
                 hasUpdates = true;
             }
             if (options.baseUrl !== undefined) {
-                body.protocol_config = { base_url: options.baseUrl };
+                body.protocol_config = { protocol: 'REST', base_url: options.baseUrl };
                 hasUpdates = true;
             }
             // Auth config updates need the discriminator

package/dist/commands/integration/version/get.js

@@ -34,7 +34,7 @@ export function createIntegrationVersionGetCommand() {
     cmd
         .description('Get version details')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -44,7 +44,7 @@ export function createIntegrationVersionGetCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             const response = await client.get(`/integration_versions/${versionId}`);
             if (getOutputMode() === 'json') {
                 output.data(response);

package/dist/commands/integration/version/publish.js

@@ -23,7 +23,7 @@ export function createIntegrationVersionPublishCommand() {
     cmd
         .description('Publish a built version')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version to publish, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version to publish, e.g. 1.0.0')
         .action(async (identifier, options) => {
         const output = createOutputWriter();
         try {
@@ -33,7 +33,7 @@ export function createIntegrationVersionPublishCommand() {
                 process.exit(1);
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             // Get current version info for display
             const currentVersion = await client.get(`/integration_versions/${versionId}`);
             const versionDisplay = currentVersion.version_number || versionId;

package/dist/commands/integration/version/test.js

@@ -22,7 +22,7 @@ export function createIntegrationVersionTestCommand() {
     cmd
         .description('Test an endpoint invocation')
         .argument('<id_or_name>', 'Integration ID or name (owner~name)')
-        .option('--version <semver>', 'Specific version, e.g. 1.0.0')
+        .option('--version-number <semver>', 'Specific version, e.g. 1.0.0')
         .requiredOption('--operation <name>', 'Operation to test, e.g. list_users')
         .option('--account <name>', 'Account name to resolve credential from')
         .option('--input-path <json>', 'JSON object of path parameters')
@@ -50,7 +50,7 @@ export function createIntegrationVersionTestCommand() {
                 body.input_body = parseJsonFlag(options.inputBody, '--input-body');
             }
             const client = new GuildAPIClient();
-            const versionId = await resolveVersionId(client, identifier, options.version);
+            const versionId = await resolveVersionId(client, identifier, options.versionNumber);
             if (options.account) {
                 const creds = await client.get(`/accounts/${options.account}/credentials?integration=${encodeURIComponent(identifier)}`);
                 if (creds.items.length === 0) {

package/dist/commands/session/events.js

@@ -3,6 +3,7 @@
 import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
+import { parseEventFilter } from '../../lib/event-filter.js';
 import { handleAxiosError } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
 export function createSessionEventsCommand() {
@@ -10,7 +11,7 @@ export function createSessionEventsCommand() {
     cmd
         .description('List events in a session')
         .argument('<session-id>', 'Session ID')
-        .option('--types <types>', 'Comma-separated event types to filter (e.g., user_message,agent_notification_message)')
+        .option('--events <types>', 'Event types to show. Shorthands: none, user, system, all, or comma-separated type names')
         .option('--limit <number>', 'Number of results to return', '100')
         .option('--offset <number>', 'Offset for pagination', '0')
         .action(async (sessionId, options) => {
@@ -25,8 +26,11 @@ export function createSessionEventsCommand() {
             const params = new URLSearchParams();
             params.append('limit', options.limit);
             params.append('offset', options.offset);
-            if (options.types) {
-                params.append('types', options.types);
+            if (options.events) {
+                const filter = parseEventFilter(options.events);
+                if (filter.size > 0) {
+                    params.append('types', [...filter].join(','));
+                }
             }
             const response = await client.get(`/sessions/${sessionId}/events?${params.toString()}`);
             output.data(response);

package/dist/commands/session/tasks.js

@@ -4,7 +4,8 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { getAuthToken } from '../../lib/auth.js';
 import { handleAxiosError } from '../../lib/errors.js';
-import { createOutputWriter } from '../../lib/output.js';
+import { getOutputMode } from '../../lib/output-mode.js';
+import { createOutputWriter, formatTaskTable } from '../../lib/output.js';
 export function createSessionTasksCommand() {
     const cmd = new Command('tasks');
     cmd
@@ -25,7 +26,12 @@ export function createSessionTasksCommand() {
             params.append('limit', options.limit);
             params.append('offset', options.offset);
             const response = await client.get(`/sessions/${sessionId}/tasks?${params.toString()}`);
-            output.data(response);
+            if (getOutputMode() === 'json') {
+                console.log(JSON.stringify(response, null, 2));
+            }
+            else {
+                formatTaskTable(response.items, response.pagination);
+            }
         }
         catch (error) {
             const formattedError = handleAxiosError(error);

package/dist/commands/workspace/get.js

@@ -8,7 +8,7 @@ export function createWorkspaceGetCommand() {
     const cmd = new Command('get');
     cmd
         .description('Get workspace details')
-        .argument('<identifier>', 'Workspace ID or full name (e.g., owner/workspace-name)')
+        .argument('<identifier>', 'Workspace ID or full name (e.g., owner~workspace-name)')
         .action(async (id) => {
         const output = createOutputWriter();
         try {

package/dist/commands/workspace/list.js

@@ -11,16 +11,38 @@ export function createWorkspaceListCommand() {
         .description('List workspaces')
         .option('--limit <number>', 'Number of results to return', '20')
         .option('--offset <number>', 'Offset for pagination', '0')
+        .option('--owner <name>', 'Filter workspaces by owner name (case-insensitive)')
         .action(async (options) => {
         const output = createOutputWriter();
         try {
             const client = new GuildAPIClient();
-            const params = new URLSearchParams();
-            // Use filter=all to get workspaces from all orgs user is a member of
-            params.append('filter', 'all');
-            params.append('limit', options.limit);
-            params.append('offset', options.offset);
-            const response = await client.get(`/me/workspaces?${params.toString()}`);
+            let response;
+            if (options.owner) {
+                // When filtering by owner, fetch ALL workspaces first so the
+                // client-side filter is applied to the complete dataset, not just
+                // one page.  The backend's `filter` param only recognises "all" vs
+                // personal; owner-name filtering is not supported server-side.
+                const allWorkspaces = await client.fetchAll('/me/workspaces?filter=all');
+                const ownerLower = options.owner.toLowerCase();
+                const filtered = allWorkspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerLower);
+                response = {
+                    items: filtered,
+                    pagination: {
+                        total_count: filtered.length,
+                        limit: filtered.length,
+                        offset: 0,
+                        has_more: false,
+                    },
+                };
+            }
+            else {
+                const params = new URLSearchParams();
+                // Use filter=all to get workspaces from all orgs the user is a member of.
+                params.append('filter', 'all');
+                params.append('limit', options.limit);
+                params.append('offset', options.offset);
+                response = await client.get(`/me/workspaces?${params.toString()}`);
+            }
             if (getOutputMode() === 'json') {
                 console.log(JSON.stringify(response, null, 2));
             }

package/dist/commands/workspace/select.js

@@ -35,8 +35,10 @@ export function createWorkspaceSelectCommand() {
     cmd
         .description('Select default workspace for agent testing')
         .argument('[workspace]', 'Workspace name or ID to select directly')
-        .action(async (workspaceArg) => {
+        .option('--owner <name>', 'Filter workspaces by owner name (case-insensitive)')
+        .action(async (workspaceArg, options = {}) => {
         const output = createOutputWriter();
+        const ownerFilter = options.owner;
         try {
             const client = new GuildAPIClient();
             // If a workspace argument was provided, use server-side search to find it
@@ -45,19 +47,34 @@ export function createWorkspaceSelectCommand() {
                 // The backend searches only the "name" column via ILIKE, so full_name (owner/name)
                 // and ID lookups may not return results. Extract just the name part for search,
                 // and if still no match, fall back to fetching the full list.
+                // Always use filter=all — the backend's `filter` param only recognises "all"
+                // vs personal; owner-name filtering is applied client-side below.
                 const searchTerm = workspaceArg.includes('/')
-                    ? workspaceArg.split('/').pop()
+                    ? (workspaceArg.split('/').pop() ?? workspaceArg)
                     : workspaceArg;
                 const searchResults = await client.get(`/me/workspaces?filter=all&search=${encodeURIComponent(searchTerm)}&limit=100`);
-                let workspace = searchResults.items.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                let candidates = searchResults.items;
+                // Apply client-side owner filter on search results
+                if (ownerFilter) {
+                    candidates = candidates.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase());
+                }
                 // Search didn't find it (could be an ID lookup, or search term didn't match).
                 // Fall back to fetching all workspaces via pagination.
-                if (!workspace) {
+                const directMatch = candidates.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                if (!directMatch) {
                     const allWorkspaces = await client.fetchAll('/me/workspaces?filter=all');
-                    workspace = allWorkspaces.find((w) => matchesWorkspaceArg(w, workspaceArg));
+                    candidates = ownerFilter
+                        ? allWorkspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase())
+                        : allWorkspaces;
                 }
+                const workspace = candidates.find((w) => matchesWorkspaceArg(w, workspaceArg));
                 if (!workspace) {
-                    output.error(`Workspace "${workspaceArg}" not found.`, 'Run: guild workspace list');
+                    if (ownerFilter) {
+                        output.error(`Workspace "${workspaceArg}" not found for owner "${ownerFilter}".`, 'Run: guild workspace list');
+                    }
+                    else {
+                        output.error(`Workspace "${workspaceArg}" not found.`, 'Run: guild workspace list');
+                    }
                     process.exit(1);
                 }
                 const target = await saveWorkspaceConfig(workspace.id, workspace.name);
@@ -73,10 +90,20 @@ export function createWorkspaceSelectCommand() {
                 output.error('Interactive mode requires a terminal.', 'Provide a workspace argument:\n  guild workspace select <name|id>');
                 process.exit(1);
             }
-            // Interactive mode: fetch all workspaces across all pages
-            const workspaces = await client.fetchAll('/me/workspaces?filter=all');
+            // Interactive mode: fetch all workspaces across all pages.
+            // Always use filter=all; owner-name filtering is applied client-side
+            // (the backend's `filter` param only recognises "all" vs personal).
+            let workspaces = await client.fetchAll('/me/workspaces?filter=all');
+            if (ownerFilter) {
+                workspaces = workspaces.filter((w) => w.owner?.name?.toLowerCase() === ownerFilter.toLowerCase());
+            }
             if (workspaces.length === 0) {
-                output.error('No workspaces found.', 'Create a workspace first:\n  guild workspace create <name>');
+                if (ownerFilter) {
+                    output.error(`No workspaces found for owner "${ownerFilter}".`, 'Run: guild workspace list');
+                }
+                else {
+                    output.error('No workspaces found.', 'Create a workspace first:\n  guild workspace create <name>');
+                }
                 process.exit(1);
             }
             // Resolve the currently selected workspace (if any)
@@ -101,6 +128,10 @@ export function createWorkspaceSelectCommand() {
                 },
             });
             const selectedWorkspace = workspaces.find((w) => w.id === selectedId);
+            if (!selectedWorkspace) {
+                output.error('Selected workspace not found');
+                process.exit(1);
+            }
             const target = await saveWorkspaceConfig(selectedWorkspace.id, selectedWorkspace.name);
             if (target === 'local') {
                 output.success(`Workspace set for this agent: ${formatWorkspaceDisplay(selectedWorkspace)}`);

package/dist/components/TaskView.js

@@ -87,7 +87,7 @@ function calculateTaskDepths(tasks) {
     const taskMap = new Map(tasks.map((t) => [t.id, t]));
     function getDepth(taskId) {
         if (depthMap.has(taskId))
-            return depthMap.get(taskId);
+            return depthMap.get(taskId) ?? 0;
         const task = taskMap.get(taskId);
         const parentId = task?.parent_task?.id;
         if (!parentId) {
@@ -167,7 +167,7 @@ export function TaskView({ tasks }) {
             if (!tasksByParent.has(parentId)) {
                 tasksByParent.set(parentId, []);
             }
-            tasksByParent.get(parentId).push(task);
+            tasksByParent.get(parentId)?.push(task);
         });
         // Process root tasks first, then children
         const processedIds = new Set();

package/dist/lib/agent-helpers.d.ts

@@ -1,10 +1,26 @@
 import { LocalConfig } from './guild-config.js';
 import { GuildAPIClient } from './api-client.js';
+import type { AgentVersion } from './api-types.js';
+/** Thrown when the ephemeral version build times out or polling fails. */
+export declare class BuildTimeoutError extends Error {
+    constructor(message?: string);
+}
+/** Thrown when the ephemeral version build fails validation. */
+export declare class BuildFailedError extends Error {
+    readonly failedSteps: {
+        name: string;
+        content?: string;
+    }[];
+    constructor(failedSteps: {
+        name: string;
+        content?: string;
+    }[]);
+}
 /**
  * Resolve an agent identifier to a fully-qualified form.
  *
- * If the identifier already contains `/` or is a UUID, return it verbatim.
- * Otherwise, resolve the default owner and prepend `owner.name/`.
+ * If the identifier already contains `~` or is a UUID, return it verbatim.
+ * Otherwise, resolve the default owner and prepend `owner.name~`.
  */
 export declare function resolveAgentRef(client: GuildAPIClient, identifier: string): Promise<string>;
 /**
@@ -27,4 +43,60 @@ export declare function readAgentFiles(cwd: string): Promise<{
     path: string;
     content: string;
 }[]>;
+/**
+ * Compute a deterministic hash of agent files.
+ * Sorts by path to ensure consistent ordering.
+ */
+export declare function hashAgentFiles(files: {
+    path: string;
+    content: string;
+}[]): string;
+/**
+ * Get or create an ephemeral version, skipping the build if files haven't
+ * changed since the last successful ephemeral build.
+ *
+ * Returns the version (cached or newly created), a cache hit flag, and the
+ * computed hash (used by buildEphemeralVersion to write the cache on success).
+ */
+export declare function getOrCreateEphemeral(client: GuildAPIClient, agentId: string, files: {
+    path: string;
+    content: string;
+}[], cwd: string, summary: string, options?: {
+    noCache?: boolean;
+}): Promise<{
+    version: AgentVersion;
+    cached: boolean;
+    hash: string;
+}>;
+/**
+ * Build an ephemeral version end-to-end: get-or-create, poll for validation,
+ * cache on success, and report build failures.
+ *
+ * Consolidates the build/poll/cache pattern used by both `guild agent test`
+ * and `guild agent chat`.
+ */
+export declare function buildEphemeralVersion(client: GuildAPIClient, agentId: string, files: {
+    path: string;
+    content: string;
+}[], cwd: string, summary: string, options?: {
+    noCache?: boolean;
+}): Promise<{
+    version: AgentVersion;
+    cached: boolean;
+}>;
+/** Thrown when the specified bundle file cannot be found on disk. */
+export declare class BundleNotFoundError extends Error {
+    constructor(filePath: string);
+}
+/**
+ * Upload a pre-built bundle as an ephemeral version.
+ *
+ * The bundle file must be gzip+base64 encoded (the output of
+ * `esbuild ... | gzip | base64`). Source files are included for
+ * dashboard viewing, but the server skips its own build step because
+ * the ready-to-run artifact is already provided.
+ */
+export declare function buildBundledVersion(client: GuildAPIClient, agentId: string, bundlePath: string, cwd: string, summary: string): Promise<{
+    version: AgentVersion;
+}>;
 //# sourceMappingURL=agent-helpers.d.ts.map