@guildai/cli 0.11.0 → 0.12.1

package/dist/lib/session-polling.js

@@ -1,166 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-import { debug, isDebugMode } from './errors.js';
-import { shouldShowEvent } from './event-filter.js';
-import { fetchEvents } from './session-events-fetch.js';
-import { applyResponseStreamText, getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
-/**
- * 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).
- *
- * Priority:
- * 1. root agent_notification_message — preferred, immediate return
- * 2. root runtime_error — fail fast
- * 3. root runtime_done content — fallback for one-shot agents
- * 4. root done response-stream after root runtime_done — streaming fallback
- */
-export async function pollForResponse(client, sessionId, afterEventId, maxWaitTime = 60000) {
-    const startTime = Date.now();
-    let fromId = afterEventId;
-    let responseStreamDone = null;
-    const responseStreamTexts = new Map();
-    while (Date.now() - startTime < maxWaitTime) {
-        const events = await fetchEvents(client, sessionId, { fromId });
-        let lastAgentRuntimeDone = null;
-        let rootRuntimeDone = false;
-        for (const event of events) {
-            debug(`pollForResponse event: ${event.type}`);
-            if (event.type === 'agent_notification_message') {
-                if (isResponseStreamEvent(event)) {
-                    const streamText = applyResponseStreamText(responseStreamTexts.get(event.content.stream_id) ?? '', event.content);
-                    responseStreamTexts.set(event.content.stream_id, streamText);
-                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
-                        responseStreamDone = {
-                            response: streamText,
-                            lastEventId: event.id,
-                        };
-                    }
-                    continue;
-                }
-                if (!isRootTaskEvent(event))
-                    continue;
-                return {
-                    response: getAgentNotificationText(event),
-                    lastEventId: event.id,
-                };
-            }
-            if (event.type === 'runtime_done' &&
-                event.task &&
-                'agent' in event.task &&
-                isRootTaskEvent(event)) {
-                rootRuntimeDone = true;
-                if (event.content !== undefined) {
-                    lastAgentRuntimeDone = JSON.stringify(event.content);
-                }
-            }
-            if (event.type === 'runtime_error' &&
-                event.task &&
-                'agent' in event.task &&
-                isRootTaskEvent(event)) {
-                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 { response: lastAgentRuntimeDone, lastEventId: fromId };
-        }
-        if (rootRuntimeDone && responseStreamDone !== null) {
-            return { response: responseStreamDone.response, lastEventId: fromId };
-        }
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-    }
-    return responseStreamDone
-        ? { response: responseStreamDone.response, lastEventId: fromId }
-        : { response: null, lastEventId: fromId };
-}
-/**
- * Poll for agent response while streaming matching events to stdout as JSONL.
- *
- * Same completion logic as pollForResponse(), but writes each event that
- * passes the filter to stdout so callers get intermediate output (console.log,
- * progress, etc.) in JSON/JSONL automation modes.
- */
-export async function pollForResponseWithEvents(client, sessionId, eventFilter, afterEventId, maxWaitTime = 60000) {
-    const startTime = Date.now();
-    let fromId = afterEventId;
-    let responseStreamDone = null;
-    const responseStreamTexts = new Map();
-    while (Date.now() - startTime < maxWaitTime) {
-        const events = await fetchEvents(client, sessionId, { fromId });
-        let lastAgentRuntimeDone = null;
-        let rootRuntimeDone = false;
-        for (const event of events) {
-            debug(`pollForResponseWithEvents event: ${event.type}`);
-            // Stream matching events to stdout as JSONL. Response-stream events are
-            // transient drafts, so keep automation output stable and wait for the
-            // final agent message or terminal fallback.
-            if (shouldShowEvent(event.type, eventFilter) && !isResponseStreamEvent(event)) {
-                process.stdout.write(JSON.stringify(event) + '\n');
-            }
-            if (event.type === 'agent_notification_message') {
-                if (isResponseStreamEvent(event)) {
-                    const streamText = applyResponseStreamText(responseStreamTexts.get(event.content.stream_id) ?? '', event.content);
-                    responseStreamTexts.set(event.content.stream_id, streamText);
-                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
-                        responseStreamDone = {
-                            response: streamText,
-                            lastEventId: event.id,
-                        };
-                    }
-                    continue;
-                }
-                if (!isRootTaskEvent(event))
-                    continue;
-                return {
-                    response: getAgentNotificationText(event),
-                    lastEventId: event.id,
-                };
-            }
-            if (event.type === 'runtime_done' &&
-                event.task &&
-                'agent' in event.task &&
-                isRootTaskEvent(event)) {
-                rootRuntimeDone = true;
-                if (event.content !== undefined) {
-                    lastAgentRuntimeDone = JSON.stringify(event.content);
-                }
-            }
-            if (event.type === 'runtime_error' &&
-                event.task &&
-                'agent' in event.task &&
-                isRootTaskEvent(event)) {
-                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 { response: lastAgentRuntimeDone, lastEventId: fromId };
-        }
-        if (rootRuntimeDone && responseStreamDone !== null) {
-            return { response: responseStreamDone.response, lastEventId: fromId };
-        }
-        await new Promise((resolve) => setTimeout(resolve, 2000));
-    }
-    return responseStreamDone
-        ? { response: responseStreamDone.response, lastEventId: fromId }
-        : { response: null, lastEventId: fromId };
-}
-//# sourceMappingURL=session-polling.js.map

package/dist/lib/session-resume.js

@@ -1,229 +0,0 @@
-// Copyright 2026 Guild.ai
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Session resume utilities - shared helpers for printing resume hints
- * and fetching/converting session events for resume.
- */
-import chalk from 'chalk';
-import { marked } from 'marked';
-import { markedTerminal } from 'marked-terminal';
-import { applyResponseStreamText, getAgentNotificationText, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
-import { fetchEvents } from './session-events-fetch.js';
-import { brand, code as codeColor } from './colors.js';
-// Configure marked for terminal rendering (same config as chat.tsx)
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-marked.use(markedTerminal({}, { theme: {} }));
-/**
- * Render markdown text to ANSI terminal output.
- * Matches the live message rendering pipeline in chat.tsx.
- */
-function renderMarkdown(text) {
-    let rendered = marked.parse(text);
-    // Fix unrendered inline markdown in list items (marked-terminal bug)
-    rendered = rendered.replace(/\*\*([^*]+)\*\*/g, (_, content) => chalk.bold(content));
-    rendered = rendered.replace(/`([^`]+)`/g, (_, content) => codeColor(content));
-    rendered = rendered.replace(/(?<![\\w])_([^_]+)_(?![\\w])/g, (_, content) => chalk.italic(content));
-    return rendered;
-}
-/**
- * Print a dimmed resume hint to stderr on session exit.
- * Only call when a session ID is available.
- */
-export function printResumeHint(sessionId, command) {
-    console.error('');
-    console.error(chalk.dim('[Session interrupted]'));
-    console.error(chalk.dim('Resume this session later with:'));
-    console.error(chalk.dim(`  ${command} --resume ${sessionId}`));
-}
-/**
- * Fetch all events for a session from the API.
- */
-export async function fetchSessionEvents(client, sessionId) {
-    return fetchEvents(client, sessionId);
-}
-/**
- * Fetch an existing session by ID.
- */
-export async function fetchSession(client, sessionId) {
-    const session = (await client.get(`/sessions/${sessionId}`));
-    return session;
-}
-function renderAssistantText(key, text, timestamp) {
-    const rendered = renderMarkdown(text);
-    const messageContent = `${chalk.green('●')} ${chalk.bold('assistant')}\n${rendered.trim()}`;
-    return {
-        key,
-        content: messageContent,
-        type: 'assistant',
-        timestamp,
-    };
-}
-function textMatches(left, right) {
-    return left === right;
-}
-function formatDisplayTimestamp(timestamp) {
-    if (timestamp === undefined)
-        return undefined;
-    const date = new Date(timestamp);
-    if (Number.isNaN(date.getTime()))
-        return timestamp;
-    return date.toLocaleTimeString();
-}
-function upsertResponseStreamEvent(events, event) {
-    const existingIndex = events.findIndex((existing) => existing.content.sequence === event.content.sequence);
-    if (existingIndex === -1) {
-        events.push(event);
-    }
-    else {
-        events[existingIndex] = event;
-    }
-}
-function collectResponseStreamResumeEntries(events) {
-    const responseStreamGroups = new Map();
-    const finalMessagesByTask = new Map();
-    for (const [index, event] of events.entries()) {
-        if (event.type !== 'agent_notification_message')
-            continue;
-        if (!isRootTaskEvent(event))
-            continue;
-        if (isResponseStreamEvent(event)) {
-            const streamId = event.content.stream_id;
-            const current = responseStreamGroups.get(streamId);
-            if (current) {
-                upsertResponseStreamEvent(current.events, event);
-                // Insertion order and sequence can diverge if backfilled events arrive out
-                // of order; use insertion index only for "later final message" dedupe.
-                current.lastIndex = Math.max(current.lastIndex, index);
-            }
-            else {
-                responseStreamGroups.set(streamId, {
-                    events: [event],
-                    lastIndex: index,
-                });
-            }
-            continue;
-        }
-        const taskId = event.task?.id;
-        if (!taskId)
-            continue;
-        const text = getAgentNotificationText(event);
-        if (!text.trim())
-            continue;
-        const finalMessages = finalMessagesByTask.get(taskId) ?? [];
-        finalMessages.push({ index, text });
-        finalMessagesByTask.set(taskId, finalMessages);
-    }
-    const entries = [];
-    for (const [streamId, streamGroup] of responseStreamGroups.entries()) {
-        const streamEvents = [...streamGroup.events].sort((left, right) => left.content.sequence - right.content.sequence);
-        const latest = streamEvents[streamEvents.length - 1];
-        const text = streamEvents.reduce((currentText, streamEvent) => applyResponseStreamText(currentText, streamEvent.content), '');
-        const taskId = latest.task?.id;
-        const matchingLaterFinalMessage = taskId !== undefined &&
-            (finalMessagesByTask.get(taskId) ?? []).some((message) => message.index > streamGroup.lastIndex && textMatches(text, message.text));
-        if (latest.content.status !== 'aborted' &&
-            !matchingLaterFinalMessage &&
-            text.trim()) {
-            entries.push({
-                streamId,
-                key: `response-stream-${streamId}`,
-                contents: streamEvents.map((event) => event.content),
-                text,
-                status: latest.content.status,
-                timestamp: formatDisplayTimestamp(latest.created_at),
-                taskId,
-            });
-        }
-    }
-    return entries;
-}
-function responseStreamResumeStateFromEntries(entries) {
-    const state = {
-        keys: new Map(),
-        contents: new Map(),
-        texts: new Map(),
-        timestamps: new Map(),
-        statuses: new Map(),
-        keysByTask: new Map(),
-    };
-    for (const entry of entries) {
-        state.keys.set(entry.streamId, entry.key);
-        state.contents.set(entry.streamId, entry.contents);
-        state.texts.set(entry.streamId, entry.text);
-        state.statuses.set(entry.streamId, entry.status);
-        if (entry.timestamp !== undefined) {
-            state.timestamps.set(entry.streamId, entry.timestamp);
-        }
-        if (entry.taskId !== undefined) {
-            const keys = state.keysByTask.get(entry.taskId) ?? new Set();
-            keys.add(entry.key);
-            state.keysByTask.set(entry.taskId, keys);
-        }
-    }
-    return state;
-}
-export function responseStreamResumeStateFromEvents(events) {
-    return responseStreamResumeStateFromEntries(collectResponseStreamResumeEntries(events));
-}
-function eventsToDisplayMessagesWithResponseStreamEntries(events, responseStreamEntries) {
-    const messages = [];
-    const responseStreamEntriesById = new Map(responseStreamEntries.map((entry) => [entry.streamId, entry]));
-    const renderedResponseStreamIds = new Set();
-    for (const event of events) {
-        if (event.type === 'user_message') {
-            messages.push({
-                key: event.id,
-                content: `${brand('>')} ${event.content}`,
-                type: 'user',
-                timestamp: event.created_at,
-            });
-        }
-        else if (event.type === 'agent_notification_message') {
-            if (isResponseStreamEvent(event)) {
-                if (!isRootTaskEvent(event))
-                    continue;
-                const streamId = event.content.stream_id;
-                if (renderedResponseStreamIds.has(streamId))
-                    continue;
-                const streamEntry = responseStreamEntriesById.get(streamId);
-                if (!streamEntry)
-                    continue;
-                renderedResponseStreamIds.add(streamId);
-                messages.push(renderAssistantText(streamEntry.key, streamEntry.text, streamEntry.timestamp));
-                continue;
-            }
-            const text = getAgentNotificationText(event);
-            if (text.trim()) {
-                messages.push(renderAssistantText(event.id, text, event.created_at));
-            }
-        }
-        else if (event.type === 'agent_notification_error') {
-            const text = typeof event.content === 'string' ? event.content : event.content?.data || '';
-            if (text.trim()) {
-                messages.push({
-                    key: event.id,
-                    content: `${chalk.red('●')} ${chalk.bold('assistant')}\n${chalk.red(text)}`,
-                    type: 'assistant',
-                    timestamp: event.created_at,
-                });
-            }
-        }
-    }
-    return messages;
-}
-export function prepareSessionResumeDisplay(events) {
-    const responseStreamEntries = collectResponseStreamResumeEntries(events);
-    return {
-        displayMessages: eventsToDisplayMessagesWithResponseStreamEntries(events, responseStreamEntries),
-        responseStreamState: responseStreamResumeStateFromEntries(responseStreamEntries),
-    };
-}
-/**
- * Convert session events to display messages for resume.
- * Maps user_message, agent_notification_message, and agent_notification_error
- * to DisplayMessage objects. Skips progress, console, runtime events.
- */
-export function eventsToDisplayMessages(events) {
-    return prepareSessionResumeDisplay(events).displayMessages;
-}
-//# sourceMappingURL=session-resume.js.map