@guildai/cli 0.6.0 → 0.6.2

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

@@ -0,0 +1,104 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { GuildAPIClient } from '../../../lib/api-client.js';
+import { getAuthToken } from '../../../lib/auth.js';
+import { handleAxiosError } from '../../../lib/errors.js';
+import { getOutputMode } from '../../../lib/output-mode.js';
+import { createOutputWriter } from '../../../lib/output.js';
+import { resolveVersionId } from '../../../lib/integration-helpers.js';
+function parseJsonFlag(value, flagName) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid JSON for ${flagName}: ${msg}`);
+    }
+}
+export function createIntegrationVersionTestCommand() {
+    const cmd = new Command('test');
+    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')
+        .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')
+        .option('--input-query <json>', 'JSON object of query parameters')
+        .option('--input-body <json>', 'JSON object for request body')
+        .action(async (identifier, options) => {
+        const output = createOutputWriter();
+        try {
+            const token = await getAuthToken();
+            if (!token) {
+                output.error('Not authenticated. Please log in first.', 'Run: guild auth login');
+                process.exit(1);
+            }
+            // Validate JSON inputs before any API calls
+            const body = {
+                operation: options.operation,
+            };
+            if (options.inputPath) {
+                body.input_path = parseJsonFlag(options.inputPath, '--input-path');
+            }
+            if (options.inputQuery) {
+                body.input_query = parseJsonFlag(options.inputQuery, '--input-query');
+            }
+            if (options.inputBody) {
+                body.input_body = parseJsonFlag(options.inputBody, '--input-body');
+            }
+            const client = new GuildAPIClient();
+            const versionId = await resolveVersionId(client, identifier, options.version);
+            if (options.account) {
+                const creds = await client.get(`/accounts/${options.account}/credentials?integration=${encodeURIComponent(identifier)}`);
+                if (creds.items.length === 0) {
+                    output.error(`Error: No credentials found for account '${options.account}' on integration '${identifier}'`);
+                    process.exit(1);
+                }
+                body.credential_id = creds.items[0].id;
+            }
+            const response = await client.post(`/integration_versions/${versionId}/test`, body);
+            if (getOutputMode() === 'json') {
+                output.data(response);
+            }
+            else {
+                console.log(`Testing operation: ${options.operation}`);
+                console.log();
+                console.log(chalk.bold('Request'));
+                console.log(`  ${'URL'.padEnd(9)}${response.request_url}`);
+                console.log();
+                console.log(chalk.bold('Response'));
+                console.log(`  ${'Status'.padEnd(9)}${response.status_code}`);
+                console.log(`  ${'Type'.padEnd(9)}${response.content_type || chalk.dim('—')}`);
+                console.log();
+                console.log(chalk.bold('Body'));
+                if (response.body !== null && response.body !== undefined) {
+                    const bodyStr = typeof response.body === 'string'
+                        ? response.body
+                        : JSON.stringify(response.body, null, 2);
+                    const indented = bodyStr
+                        .split('\n')
+                        .map((line) => `  ${line}`)
+                        .join('\n');
+                    console.log(indented);
+                }
+                else {
+                    console.log(chalk.dim('  (empty)'));
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith('Invalid JSON')) {
+                output.error(`Error: ${error.message}`);
+                process.exit(1);
+            }
+            const formattedError = handleAxiosError(error);
+            output.error(`Failed to test endpoint: ${formattedError.details}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}
+//# sourceMappingURL=test.js.map

package/dist/commands/workspace/create.js

@@ -4,21 +4,27 @@ import { Command } from 'commander';
 import { GuildAPIClient } from '../../lib/api-client.js';
 import { handleAxiosError, ErrorCodes } from '../../lib/errors.js';
 import { createOutputWriter } from '../../lib/output.js';
+import { resolveOwnerId } from '../../lib/owner-helpers.js';
+import { isInteractive } from '../../lib/stdin.js';
 export function createWorkspaceCreateCommand() {
     const cmd = new Command('create');
     cmd
         .description('Create a new workspace')
         .argument('<name>', 'Workspace name')
-        .action(async (name) => {
+        .option('--owner <owner>', 'Owner (name or ID)')
+        .action(async (name, options) => {
         const output = createOutputWriter();
         try {
             const client = new GuildAPIClient();
-            // Get current user info to use as workspace owner
-            const me = (await client.get('/me'));
+            const owner = await resolveOwnerId({
+                ownerFlag: options.owner,
+                client,
+                interactive: isInteractive(),
+            });
             // Create workspace
             const workspace = await client.post('/workspaces', {
                 name,
-                owner_id: me.id,
+                owner_id: owner.id,
             });
             output.data(workspace);
         }

package/dist/index.js

@@ -74,6 +74,19 @@ import { createCredentialsPolicyUpdateCommand } from './commands/credentials/pol
 import { createDoctorCommand } from './commands/doctor.js';
 import { createSetupCommand } from './commands/setup.js';
 import { createMcpCommand } from './commands/mcp.js';
+import { createIntegrationListCommand } from './commands/integration/list.js';
+import { createIntegrationGetCommand } from './commands/integration/get.js';
+import { createIntegrationCreateCommand } from './commands/integration/create.js';
+import { createIntegrationUpdateCommand } from './commands/integration/update.js';
+import { createIntegrationConnectCommand } from './commands/integration/connect.js';
+import { createIntegrationVersionListCommand } from './commands/integration/version/list.js';
+import { createIntegrationVersionCreateCommand } from './commands/integration/version/create.js';
+import { createIntegrationVersionGetCommand } from './commands/integration/version/get.js';
+import { createIntegrationVersionBuildCommand } from './commands/integration/version/build.js';
+import { createIntegrationVersionPublishCommand } from './commands/integration/version/publish.js';
+import { createIntegrationVersionTestCommand } from './commands/integration/version/test.js';
+import { createIntegrationOperationListCommand } from './commands/integration/operation/list.js';
+import { createIntegrationOperationCreateCommand } from './commands/integration/operation/create.js';
 import { showSplashScreen, shouldShowSplash } from './lib/splash.js';
 import { checkForUpdate } from './lib/update-check.js';
 import { setupUnknownCommandSuggestions } from './lib/did-you-mean.js';
@@ -153,6 +166,31 @@ tagsCmd.addCommand(createAgentTagsListCommand());
 tagsCmd.addCommand(createAgentTagsAddCommand());
 tagsCmd.addCommand(createAgentTagsRemoveCommand());
 tagsCmd.addCommand(createAgentTagsSetCommand());
+// Integration command group
+const integrationCmd = program
+    .command('integration')
+    .description('Manage integrations');
+integrationCmd.addCommand(createIntegrationListCommand());
+integrationCmd.addCommand(createIntegrationGetCommand());
+integrationCmd.addCommand(createIntegrationCreateCommand());
+integrationCmd.addCommand(createIntegrationUpdateCommand());
+integrationCmd.addCommand(createIntegrationConnectCommand());
+// Integration version subcommand group
+const integrationVersionCmd = integrationCmd
+    .command('version')
+    .description('Manage integration versions');
+integrationVersionCmd.addCommand(createIntegrationVersionListCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionCreateCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionGetCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionBuildCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionPublishCommand());
+integrationVersionCmd.addCommand(createIntegrationVersionTestCommand());
+// Integration operation subcommand group
+const integrationOperationCmd = integrationCmd
+    .command('operation')
+    .description('Manage version operations');
+integrationOperationCmd.addCommand(createIntegrationOperationListCommand());
+integrationOperationCmd.addCommand(createIntegrationOperationCreateCommand());
 // Workspace command group
 const workspaceCmd = program.command('workspace').description('Workspace management');
 workspaceCmd.addCommand(createWorkspaceListCommand());

package/dist/lib/api-types.d.ts

@@ -204,25 +204,17 @@ export interface AgentVersionDetail {
         description: string;
     };
 }
-/**
- * Webhook config nested in integration responses.
- * Used by: trigger create (to resolve webhook_config_id)
- */
-export interface IntegrationWebhookConfig {
+export interface TriggerIntegrationWebhookConfig {
     id: string;
     enabled: boolean;
     events: Record<string, string[]>;
 }
-/**
- * Integration entity from the API.
- * Used by: trigger create (to resolve webhook_config_id from integration name)
- */
-export interface Integration {
+export interface TriggerIntegration {
     id: string;
     name: string;
     full_name: string;
     service?: string | null;
-    webhook_config: IntegrationWebhookConfig | null;
+    webhook_config: TriggerIntegrationWebhookConfig | null;
 }
 export type TriggerType = 'webhook' | 'time';
 import { WEBHOOK_SERVICES, type WebhookService, TIME_TRIGGER_FREQUENCIES, type TimeTriggerFrequency } from './generated-types.js';
@@ -267,7 +259,7 @@ export interface TriggerWebhook {
         project?: string;
         jql_filter?: string;
     } | Record<string, unknown>;
-    integration: Integration;
+    integration: TriggerIntegration;
     created_at: string;
     deactivated_at: string | null;
     disabled_reason: TriggerDisabledReason | null;
@@ -424,6 +416,71 @@ export interface JobStepsResponse {
     job_id: string;
     steps: JobStep[];
 }
+export interface IntegrationOwner {
+    id: string;
+    name: string;
+}
+export interface IntegrationAuthConfig {
+    id: string;
+    entity_type: string;
+    auth_scheme: 'API_KEY' | 'OAUTH';
+    token_header_template?: string;
+    install_url?: string;
+    token_url?: string;
+    client_id?: string;
+    scopes?: string[];
+}
+export interface IntegrationProtocolConfig {
+    protocol: 'REST';
+    base_url: string;
+}
+export interface IntegrationWebhookConfig {
+    enabled: boolean;
+    events?: string[];
+}
+export interface IntegrationPublishedVersion {
+    id: string;
+    version_number: string;
+    published_at: string;
+}
+export interface Integration {
+    id: string;
+    entity_type: string;
+    created_at: string;
+    updated_at: string;
+    name: string;
+    description: string | null;
+    is_public: boolean;
+    avatar_url: string | null;
+    owner: IntegrationOwner;
+    auth_config: IntegrationAuthConfig;
+    protocol_config: IntegrationProtocolConfig;
+    webhook_config: IntegrationWebhookConfig | null;
+    params: unknown[];
+    viewer_can_edit: boolean;
+    latest_published_version?: IntegrationPublishedVersion | null;
+}
+export type IntegrationListResponse = PaginatedResponse<Integration>;
+export interface IntegrationVersion {
+    id: string;
+    entity_type: string;
+    created_at: string;
+    updated_at: string;
+    author: {
+        id: string;
+        name: string;
+    };
+    validation_status: string;
+    published_at: string | null;
+    publishing_started_at: string | null;
+    version_number: string | null;
+    integration?: {
+        id: string;
+        name: string;
+        description: string;
+    };
+}
+export type IntegrationVersionListResponse = PaginatedResponse<IntegrationVersion>;
 /**
  * Contents of guild.json file in agent directories.
  */

package/dist/lib/auth.d.ts

@@ -50,7 +50,7 @@ export declare function showBetaGuidance(): void;
  * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
  * @returns true if successful, false otherwise
  */
-export declare function login(returnUrl?: string, returnLabel?: string, noBrowser?: boolean): Promise<boolean>;
+export declare function login(returnUrl?: string, returnLabel?: string, nonInteractive?: boolean): Promise<boolean>;
 /**
  * Perform logout
  */

package/dist/lib/auth.js

@@ -10,6 +10,7 @@ import { createSpinner } from './progress.js';
 import { getGuildcoreUrl } from './config.js';
 import { getIapHeaders } from './iap.js';
 import { brand, warn } from './colors.js';
+import { isInteractive } from './stdin.js';
 const SERVICE_NAME = 'guild-cli';
 /**
  * Get account name for keyring, keyed by host to support multiple backends
@@ -199,12 +200,12 @@ export function showBetaGuidance() {
  * @param returnLabel - Optional friendly label for return button (e.g., "VSCode")
  * @returns true if successful, false otherwise
  */
-export async function login(returnUrl, returnLabel, noBrowser) {
+export async function login(returnUrl, returnLabel, nonInteractive) {
     const authUrl = getGuildcoreUrl();
     try {
         console.log(chalk.bold('\nGuild.ai Authentication'));
         const deviceCode = await startDeviceFlow(authUrl, returnUrl, returnLabel);
-        const skipBrowser = noBrowser || process.stdin.isTTY !== true;
+        const skipBrowser = nonInteractive || !isInteractive();
         if (skipBrowser) {
             console.log(`\nVerification code: ${deviceCode.user_code}`);
             console.log(`Open to authenticate: ${deviceCode.verification_uri_complete}\n`);

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

@@ -0,0 +1,15 @@
+import { GuildAPIClient } from './api-client.js';
+/**
+ * Resolve a version ID from an integration identifier and optional semver.
+ *
+ * 1. GET /integrations/<identifier> to resolve the integration
+ * 2. GET /integrations/<id>/versions to list versions
+ * 3. If semver provided, find matching version_number; otherwise use latest (first)
+ */
+export declare function resolveVersionId(client: GuildAPIClient, identifier: string, versionNumber?: string): Promise<string>;
+/**
+ * Resolve the latest draft version ID for an integration.
+ * Used by the build command where --version is not applicable (drafts have no semver).
+ */
+export declare function resolveLatestDraftId(client: GuildAPIClient, identifier: string): Promise<string>;
+//# sourceMappingURL=integration-helpers.d.ts.map

package/dist/lib/integration-helpers.js

@@ -0,0 +1,38 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Resolve a version ID from an integration identifier and optional semver.
+ *
+ * 1. GET /integrations/<identifier> to resolve the integration
+ * 2. GET /integrations/<id>/versions to list versions
+ * 3. If semver provided, find matching version_number; otherwise use latest (first)
+ */
+export async function resolveVersionId(client, identifier, versionNumber) {
+    const integration = await client.get(`/integrations/${identifier}`);
+    const versions = await client.get(`/integrations/${integration.id}/versions?limit=100`);
+    if (versions.items.length === 0) {
+        throw new Error('No versions found for this integration');
+    }
+    if (versionNumber) {
+        const match = versions.items.find((v) => v.version_number === versionNumber);
+        if (!match) {
+            throw new Error(`Version ${versionNumber} not found`);
+        }
+        return match.id;
+    }
+    return versions.items[0].id;
+}
+/**
+ * Resolve the latest draft version ID for an integration.
+ * Used by the build command where --version is not applicable (drafts have no semver).
+ */
+export async function resolveLatestDraftId(client, identifier) {
+    const integration = await client.get(`/integrations/${identifier}`);
+    const versions = await client.get(`/integrations/${integration.id}/versions?limit=100`);
+    const draft = versions.items.find((v) => v.version_number === null);
+    if (!draft) {
+        throw new Error('No draft version found for this integration');
+    }
+    return draft.id;
+}
+//# sourceMappingURL=integration-helpers.js.map

package/dist/lib/output.d.ts

@@ -1,10 +1,20 @@
 import { type Spinner } from './progress.js';
-import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
+import type { Agent, AgentVersion, Credentials, CredentialsPolicy, Context, Integration, IntegrationVersion, JobStep, Pagination, Session, Workspace, WorkspaceAgent, Trigger } from './api-types.js';
 /**
  * Format an agent list as a human-readable table.
  * Shared by agent list and agent search commands.
  */
 export declare function formatAgentTable(agents: Agent[], pagination: Pagination): void;
+/**
+ * Format an integration list as a human-readable table.
+ * Used by integration list command.
+ */
+export declare function formatIntegrationTable(integrations: Integration[], pagination: Pagination): void;
+/**
+ * Format an integration version list as a human-readable table.
+ * Used by integration version list command.
+ */
+export declare function formatIntegrationVersionTable(versions: IntegrationVersion[], pagination: Pagination, integrationName: string): void;
 /**
  * Format an agent version list as a human-readable table.
  * Used by agent versions command.

package/dist/lib/output.js

@@ -81,6 +81,100 @@ export function formatAgentTable(agents, pagination) {
         console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} agents`));
     }
 }
+/**
+ * Format an integration list as a human-readable table.
+ * Used by integration list command.
+ */
+export function formatIntegrationTable(integrations, pagination) {
+    if (integrations.length === 0) {
+        console.log(chalk.dim('No integrations found'));
+        return;
+    }
+    const table = new Table({
+        columns: [
+            { name: 'name', title: 'NAME', alignment: 'left' },
+            { name: 'description', title: 'DESCRIPTION', alignment: 'left' },
+            { name: 'visibility', title: 'VISIBILITY', alignment: 'left' },
+            { name: 'owner', title: 'OWNER', alignment: 'left', color: 'cyan' },
+            { name: 'updated', title: 'UPDATED', alignment: 'left' },
+        ],
+    });
+    integrations.forEach((integration) => {
+        table.addRow({
+            name: integration.name,
+            description: truncate(integration.description || '', 40),
+            visibility: integration.is_public ? 'public' : 'internal',
+            owner: integration.owner?.name || '',
+            updated: integration.updated_at ? formatRelativeTime(integration.updated_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, integrations.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} integrations. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} integrations`));
+    }
+}
+/**
+ * Format an integration version list as a human-readable table.
+ * Used by integration version list command.
+ */
+export function formatIntegrationVersionTable(versions, pagination, integrationName) {
+    if (versions.length === 0) {
+        console.log(chalk.dim('No versions found'));
+        return;
+    }
+    console.log(chalk.bold(`Versions for ${integrationName}`));
+    console.log();
+    const table = new Table({
+        columns: [
+            { name: 'id', title: 'ID', alignment: 'left' },
+            { name: 'version', title: 'VERSION', alignment: 'left' },
+            { name: 'author', title: 'AUTHOR', alignment: 'left', color: 'cyan' },
+            { name: 'status', title: 'STATUS', alignment: 'left' },
+            { name: 'published', title: 'PUBLISHED', alignment: 'left' },
+            { name: 'created', title: 'CREATED', alignment: 'left' },
+        ],
+    });
+    versions.forEach((v) => {
+        let statusLabel;
+        switch (v.validation_status) {
+            case 'PASSED':
+                statusLabel = chalk.green('Valid');
+                break;
+            case 'FAILED':
+                statusLabel = chalk.red('Failed');
+                break;
+            case 'RUNNING':
+                statusLabel = chalk.yellow('Building');
+                break;
+            default:
+                statusLabel = chalk.dim('—');
+        }
+        table.addRow({
+            id: v.id,
+            version: v.version_number || 'Draft',
+            author: v.author?.name || '',
+            status: statusLabel,
+            published: v.published_at ? formatRelativeTime(v.published_at) : chalk.dim('—'),
+            created: v.created_at ? formatRelativeTime(v.created_at) : '',
+        });
+    });
+    table.printTable();
+    const showing = Math.min(pagination.limit, versions.length);
+    if (pagination.has_more) {
+        const nextOffset = pagination.offset + pagination.limit;
+        console.log(`\nShowing ${showing} of ${pagination.total_count} versions. ` +
+            chalk.dim(`Use --offset ${nextOffset} to see more.`));
+    }
+    else if (pagination.total_count > showing) {
+        console.log(chalk.dim(`\nShowing ${showing} of ${pagination.total_count} versions`));
+    }
+}
 /**
  * Format an agent version list as a human-readable table.
  * Used by agent versions command.

package/dist/lib/session-events-fetch.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared event/task fetching for session polling.
+ *
+ * Consolidates the duplicate response parsing that was scattered across
+ * chat.tsx, session-polling.ts, and session-resume.ts.
+ */
+import { GuildAPIClient } from './api-client.js';
+import { SessionEvent, SessionTask } from './session-events.js';
+interface FetchOptions {
+    /** Only return events after this event ID (server-side cursor). */
+    fromId?: string;
+    /** Maximum number of events to return. Default 1000. */
+    limit?: number;
+}
+/**
+ * Fetch session events from the API.
+ *
+ * Uses from_id cursor so callers only fetch new events
+ * instead of re-fetching everything on every poll cycle.
+ */
+export declare function fetchEvents(client: GuildAPIClient, sessionId: string, options?: FetchOptions): Promise<SessionEvent[]>;
+/**
+ * Fetch session tasks from the API.
+ */
+export declare function fetchTasks(client: GuildAPIClient, sessionId: string): Promise<SessionTask[]>;
+export {};
+//# sourceMappingURL=session-events-fetch.d.ts.map

package/dist/lib/session-events-fetch.js

@@ -0,0 +1,25 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Fetch session events from the API.
+ *
+ * Uses from_id cursor so callers only fetch new events
+ * instead of re-fetching everything on every poll cycle.
+ */
+export async function fetchEvents(client, sessionId, options = {}) {
+    const { fromId, limit = 1000 } = options;
+    let url = `/sessions/${sessionId}/events?limit=${limit}`;
+    if (fromId) {
+        url += `&from_id=${fromId}`;
+    }
+    const response = await client.get(url);
+    return response?.items || [];
+}
+/**
+ * Fetch session tasks from the API.
+ */
+export async function fetchTasks(client, sessionId) {
+    const response = await client.get(`/sessions/${sessionId}/tasks?limit=1000`);
+    return response?.items || [];
+}
+//# sourceMappingURL=session-events-fetch.js.map

package/dist/lib/session-polling.d.ts

@@ -1,6 +1,11 @@
 import { GuildAPIClient } from './api-client.js';
+export interface PollResult {
+    response: string | null;
+    /** Last event ID seen — pass as `afterEventId` on next call. */
+    lastEventId: string | undefined;
+}
 /**
- * Poll for agent response after a certain event count.
+ * Poll for agent response using from_id cursor.
  *
  * Handles both multi-turn agents (which emit agent_notification_message)
  * and one-shot agents (which may only emit runtime_done with output content).
@@ -10,5 +15,5 @@ import { GuildAPIClient } from './api-client.js';
  * 2. runtime_done from agent tasks — fallback for one-shot agents
  * 3. runtime_error from agent tasks — fail fast
  */
-export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventCount: number, maxWaitTime?: number): Promise<string | null>;
+export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventId: string | undefined, maxWaitTime?: number): Promise<PollResult>;
 //# sourceMappingURL=session-polling.d.ts.map

package/dist/lib/session-polling.js

@@ -1,8 +1,9 @@
 // Copyright 2026 Guild.ai
 // SPDX-License-Identifier: Apache-2.0
-import { isDebugMode } from './errors.js';
+import { debug, isDebugMode } from './errors.js';
+import { fetchEvents } from './session-events-fetch.js';
 /**
- * Poll for agent response after a certain event count.
+ * Poll for agent response using from_id cursor.
  *
  * Handles both multi-turn agents (which emit agent_notification_message)
  * and one-shot agents (which may only emit runtime_done with output content).
@@ -12,16 +13,16 @@ import { isDebugMode } from './errors.js';
  * 2. runtime_done from agent tasks — fallback for one-shot agents
  * 3. runtime_error from agent tasks — fail fast
  */
-export async function pollForResponse(client, sessionId, afterEventCount, maxWaitTime = 60000) {
+export async function pollForResponse(client, sessionId, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
+    let fromId = afterEventId;
     while (Date.now() - startTime < maxWaitTime) {
-        const response = await client.get(`/sessions/${sessionId}/events?limit=1000`);
-        const events = response?.items || [];
+        const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
-        for (let i = afterEventCount; i < events.length; i++) {
-            const event = events[i];
+        for (const event of events) {
+            debug(`pollForResponse event: ${event.type}`);
             if (event.type === 'agent_notification_message') {
-                return event.content.data;
+                return { response: event.content.data, lastEventId: event.id };
             }
             if (event.type === 'runtime_done' &&
                 event.content !== undefined &&
@@ -30,17 +31,23 @@ export async function pollForResponse(client, sessionId, afterEventCount, maxWai
                 lastAgentRuntimeDone = JSON.stringify(event.content);
             }
             if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
-                return JSON.stringify({ error: event.content });
+                return {
+                    response: JSON.stringify({ error: event.content }),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'agent_console' && isDebugMode()) {
                 process.stderr.write(`[console.${event.level}] ${event.content}\n`);
             }
         }
+        if (events.length > 0) {
+            fromId = events[events.length - 1].id;
+        }
         if (lastAgentRuntimeDone !== null) {
-            return lastAgentRuntimeDone;
+            return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
-        await new Promise((resolve) => setTimeout(resolve, 500));
+        await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-    return null;
+    return { response: null, lastEventId: fromId };
 }
 //# sourceMappingURL=session-polling.js.map