@botbotgo/agent-harness 0.0.309 → 0.0.311

package/dist/cli/chat-interactive.js

@@ -0,0 +1,244 @@
+import { streamChatMessage } from "./chat-stream.js";
+import { renderChatContext, renderChatHelp, renderChatPromptLine, renderRequestEvents } from "./chat-ui.js";
+import { normalizeChatCommand } from "./chat-workspace.js";
+import { renderApprovalList, renderHealthSnapshot, renderOperatorOverview, renderRequestList } from "./runtime-output.js";
+async function* iterateChatLines(lineReader, renderPrompt) {
+    lineReader.setPrompt(renderPrompt());
+    lineReader.prompt();
+    for await (const line of lineReader) {
+        yield line;
+        lineReader.setPrompt(renderPrompt());
+        lineReader.prompt();
+    }
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatTimestamp(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function renderSessionSummaries(summaries) {
+    if (summaries.length === 0) {
+        return "No sessions found.\n";
+    }
+    return summaries.map((summary) => {
+        const sessionId = typeof summary.sessionId === "string" ? summary.sessionId : "unknown";
+        const agentId = typeof summary.currentAgentId === "string"
+            ? summary.currentAgentId
+            : typeof summary.entryAgentId === "string"
+                ? summary.entryAgentId
+                : "unknown";
+        const state = typeof summary.currentState === "string" ? summary.currentState : "unknown";
+        const messageCount = typeof summary.messageCount === "number" ? ` messages=${summary.messageCount}` : "";
+        const title = typeof summary.title === "string" ? ` title=${summary.title}` : "";
+        const snippet = typeof summary.snippet === "string" ? ` snippet=${summary.snippet}` : "";
+        return `${sessionId} agent=${agentId} state=${state}${messageCount}${title}${snippet}`;
+    }).join("\n") + "\n";
+}
+function renderRequestTraceItems(traceItems) {
+    if (traceItems.length === 0) {
+        return "No trace items recorded.\n";
+    }
+    return traceItems.map((item) => {
+        const surfaceItem = isObject(item.surfaceItem) ? item.surfaceItem : {};
+        const kind = typeof surfaceItem.kind === "string" ? surfaceItem.kind : "unknown";
+        const name = typeof surfaceItem.id === "string" ? surfaceItem.id : typeof surfaceItem.name === "string" ? surfaceItem.name : "unknown";
+        const agentId = typeof surfaceItem.agentId === "string" ? ` agent=${surfaceItem.agentId}` : "";
+        const status = typeof item.status === "string" ? ` status=${item.status}` : "";
+        return `${kind}:${name}${agentId}${status}`;
+    }).join("\n") + "\n";
+}
+export async function runInteractiveChatLoop(input) {
+    let activeAgentId = input.activeAgentId;
+    let activeSessionId = input.activeSessionId;
+    let latestRequestId;
+    try {
+        for await (const raw of iterateChatLines(input.lineReader, () => renderChatPromptLine({
+            agentId: activeAgentId,
+            sessionId: activeSessionId,
+            requestId: latestRequestId,
+            color: input.useColor,
+        }))) {
+            const trimmed = raw.trim();
+            if (!trimmed) {
+                continue;
+            }
+            const chatCommand = normalizeChatCommand(trimmed);
+            if (!chatCommand) {
+                const streamed = await streamChatMessage({
+                    client: input.client,
+                    stdout: input.stdout,
+                    stdoutStream: input.stdoutStream,
+                    stderr: input.stderr,
+                    stderrStream: input.stderrStream,
+                    agentId: activeAgentId,
+                    sessionId: activeSessionId,
+                    message: trimmed,
+                    modelInfo: input.workspaceModelInfo,
+                    requestEvents: input.requestEvents,
+                    liveRequestTree: input.requestEvents && input.chatIsTty,
+                    colorRequestTree: input.useColor,
+                    showToolResults: input.requestEvents,
+                    showRunningState: false,
+                });
+                activeSessionId = streamed.sessionId;
+                latestRequestId = streamed.requestId;
+                activeAgentId = streamed.agentId ?? activeAgentId;
+                continue;
+            }
+            if (chatCommand.name === "exit" || chatCommand.name === "quit") {
+                break;
+            }
+            if (chatCommand.name === "help") {
+                input.stdout(renderChatHelp());
+                continue;
+            }
+            if (chatCommand.name === "context") {
+                input.stdout(renderChatContext({
+                    agentId: activeAgentId,
+                    sessionId: activeSessionId,
+                    requestId: latestRequestId,
+                }));
+                continue;
+            }
+            if (chatCommand.name === "new") {
+                activeSessionId = undefined;
+                latestRequestId = undefined;
+                input.stdout(renderChatContext({
+                    agentId: activeAgentId,
+                    sessionId: activeSessionId,
+                    requestId: latestRequestId,
+                }));
+                continue;
+            }
+            if (chatCommand.name === "agent") {
+                if (!chatCommand.arg) {
+                    input.stdout(activeAgentId ? `${activeAgentId}\n` : "No active agent override.\n");
+                    continue;
+                }
+                activeAgentId = chatCommand.arg;
+                input.stdout(`agent=${activeAgentId}\n`);
+                continue;
+            }
+            if (chatCommand.name === "session") {
+                input.stdout(activeSessionId ? `${activeSessionId}\n` : "No active session.\n");
+                continue;
+            }
+            if (chatCommand.name === "request") {
+                if (!chatCommand.arg) {
+                    input.stdout(latestRequestId ? `${latestRequestId}\n` : "No active request.\n");
+                    continue;
+                }
+                const selected = await input.client.getRequest(chatCommand.arg);
+                if (!selected) {
+                    input.stdout(`Request not found: ${chatCommand.arg}\n`);
+                    continue;
+                }
+                latestRequestId = selected.requestId;
+                activeSessionId = selected.sessionId;
+                activeAgentId = selected.agentId;
+                input.stdout(`request=${latestRequestId} session=${activeSessionId}\n`);
+                continue;
+            }
+            if (chatCommand.name === "sessions") {
+                const summaries = await input.client.listSessionSummaries(input.agentFilter ? { agentId: input.agentFilter } : undefined);
+                input.stdout(renderSessionSummaries(summaries));
+                continue;
+            }
+            if (chatCommand.name === "requests") {
+                const requests = await input.client.listRequests(activeSessionId
+                    ? { sessionId: activeSessionId }
+                    : activeAgentId
+                        ? { agentId: activeAgentId }
+                        : undefined);
+                input.stdout(renderRequestList(requests));
+                continue;
+            }
+            if (chatCommand.name === "resume") {
+                if (!chatCommand.arg) {
+                    input.stdout("Usage: /resume <sessionId>\n");
+                    continue;
+                }
+                const session = await input.client.getSession(chatCommand.arg);
+                if (!session) {
+                    input.stdout(`Session not found: ${chatCommand.arg}\n`);
+                    continue;
+                }
+                activeSessionId = chatCommand.arg;
+                latestRequestId = session.latestRequestId;
+                activeAgentId = session.currentAgentId ?? session.entryAgentId ?? activeAgentId;
+                input.stdout(`session=${activeSessionId}\n`);
+                continue;
+            }
+            if (chatCommand.name === "cancel") {
+                if (!latestRequestId) {
+                    input.stdout("No active request.\n");
+                    continue;
+                }
+                const result = await input.client.cancelRequest({
+                    requestId: latestRequestId,
+                    reason: "Cancelled from chat CLI",
+                });
+                activeSessionId = result.sessionId;
+                latestRequestId = result.requestId;
+                input.stdout(`${result.state}: ${result.output}\n`);
+                continue;
+            }
+            if (chatCommand.name === "approvals") {
+                const approvals = await input.client.listApprovals(activeSessionId ? { sessionId: activeSessionId, status: "pending" } : { status: "pending" });
+                input.stdout(renderApprovalList(approvals));
+                continue;
+            }
+            if ((chatCommand.name === "approve" || chatCommand.name === "reject") && chatCommand.arg) {
+                const result = await input.client.resolveApproval({
+                    approvalId: chatCommand.arg,
+                    decision: chatCommand.name === "approve" ? "approve" : "reject",
+                    ...(activeSessionId ? { sessionId: activeSessionId } : {}),
+                });
+                activeSessionId = result.sessionId;
+                latestRequestId = result.requestId;
+                input.stdout(`${result.state}: ${result.output}\n`);
+                continue;
+            }
+            if (chatCommand.name === "events") {
+                if (!activeSessionId || !latestRequestId) {
+                    input.stdout("No active request.\n");
+                    continue;
+                }
+                const events = await input.client.listRequestEvents({
+                    sessionId: activeSessionId,
+                    requestId: latestRequestId,
+                });
+                input.stdout(renderRequestEvents(events));
+                continue;
+            }
+            if (chatCommand.name === "trace") {
+                if (!activeSessionId || !latestRequestId) {
+                    input.stdout("No active request.\n");
+                    continue;
+                }
+                const traceItems = await input.client.listRequestTraceItems({
+                    sessionId: activeSessionId,
+                    requestId: latestRequestId,
+                });
+                input.stdout(renderRequestTraceItems(traceItems));
+                continue;
+            }
+            if (chatCommand.name === "health") {
+                const health = await input.client.getHealth();
+                input.stdout(renderHealthSnapshot(health, input.workspacePath));
+                continue;
+            }
+            if (chatCommand.name === "overview") {
+                const overview = await input.client.getOperatorOverview({ limit: 5 });
+                input.stdout(renderOperatorOverview(overview, input.workspacePath));
+                continue;
+            }
+            input.stdout("Unknown chat command. Use /help.\n");
+        }
+    }
+    finally {
+        input.lineReader.close();
+    }
+    return { activeAgentId, activeSessionId, latestRequestId };
+}

package/dist/cli/chat-rendering.d.ts

@@ -0,0 +1,9 @@
+import { type ChatWorkspaceModelInfo } from "./chat-workspace.js";
+export declare function countRenderedLines(text: string): number;
+export declare function renderChatTextChunk(text: string, modelInfo?: ChatWorkspaceModelInfo): string;
+export declare function renderChatRequestRunning(input: {
+    sessionId?: string;
+    requestId?: string;
+    agentId?: string;
+}): string;
+export declare function summarizeChatToolResult(output: unknown, isError: boolean): string;

package/dist/cli/chat-rendering.js

@@ -0,0 +1,102 @@
+import { renderChatRuntimeFailure } from "./chat-workspace.js";
+export function countRenderedLines(text) {
+    return text.replace(/\n$/, "").split("\n").length;
+}
+export function renderChatTextChunk(text, modelInfo) {
+    return renderChatRuntimeFailure(text, modelInfo);
+}
+export function renderChatRequestRunning(input) {
+    const parts = [
+        input.sessionId ? `session=${input.sessionId}` : undefined,
+        input.requestId ? `request=${input.requestId}` : undefined,
+        input.agentId ? `agent=${input.agentId}` : undefined,
+        "running: waiting for model output",
+    ].filter((part) => typeof part === "string" && part.length > 0);
+    return `\n${parts.join(" ")}\n`;
+}
+export function summarizeChatToolResult(output, isError) {
+    if (!isError) {
+        return "completed";
+    }
+    return summarizeChatToolError(output);
+}
+function summarizeChatToolError(output) {
+    if (typeof output === "string") {
+        const trimmed = output.trim();
+        return trimmed.length > 0 ? truncateChatToolPreview(trimmed, 240) : "failed";
+    }
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    if (!output || typeof output !== "object") {
+        return "failed";
+    }
+    const typed = output;
+    const content = extractChatToolTextContent(output);
+    if (content && content.trim().length > 0) {
+        return truncateChatToolPreview(content.trim(), 240);
+    }
+    const summary = typeof typed.summary === "object" && typed.summary !== null ? typed.summary : undefined;
+    if (summary) {
+        return truncateChatToolPreview(JSON.stringify(summary, null, 2), 240);
+    }
+    return truncateChatToolPreview(JSON.stringify(output, null, 2), 240);
+}
+function truncateChatToolPreview(value, maxChars = 800) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return `${value.slice(0, maxChars - 15)}\n...[truncated]`;
+}
+function extractChatToolTextContent(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => extractChatToolTextContent(item))
+            .filter((item) => item.trim().length > 0)
+            .join("\n");
+    }
+    if (!value || typeof value !== "object") {
+        return "";
+    }
+    const typed = value;
+    if (typeof typed.text === "string") {
+        return typed.text;
+    }
+    if (typeof typed.content === "string") {
+        return typed.content;
+    }
+    if (typed.content !== undefined) {
+        const nestedContent = extractChatToolTextContent(typed.content);
+        if (nestedContent.trim().length > 0) {
+            return nestedContent;
+        }
+    }
+    if (typed.kwargs !== undefined) {
+        const nestedKwargs = extractChatToolTextContent(typed.kwargs);
+        if (nestedKwargs.trim().length > 0) {
+            return nestedKwargs;
+        }
+    }
+    if (typed.message !== undefined) {
+        const nestedMessage = extractChatToolTextContent(typed.message);
+        if (nestedMessage.trim().length > 0) {
+            return nestedMessage;
+        }
+    }
+    if (typed.body !== undefined) {
+        const nestedBody = extractChatToolTextContent(typed.body);
+        if (nestedBody.trim().length > 0) {
+            return nestedBody;
+        }
+    }
+    if (typed.answer !== undefined) {
+        const nestedAnswer = extractChatToolTextContent(typed.answer);
+        if (nestedAnswer.trim().length > 0) {
+            return nestedAnswer;
+        }
+    }
+    return "";
+}

package/dist/cli/chat-stream.d.ts

@@ -0,0 +1,23 @@
+import type { Writable as WritableStream } from "node:stream";
+import type { HarnessClient } from "../client.js";
+import type { ChatWorkspaceModelInfo } from "./chat-workspace.js";
+export declare function streamChatMessage(input: {
+    client: HarnessClient;
+    stdout: (message: string) => void;
+    stdoutStream?: WritableStream;
+    stderr: (message: string) => void;
+    stderrStream?: WritableStream;
+    agentId?: string;
+    sessionId?: string;
+    message: string;
+    modelInfo?: ChatWorkspaceModelInfo;
+    requestEvents?: boolean;
+    liveRequestTree?: boolean;
+    colorRequestTree?: boolean;
+    showToolResults?: boolean;
+    showRunningState?: boolean;
+}): Promise<{
+    sessionId?: string;
+    requestId?: string;
+    agentId?: string;
+}>;