@psnext/slingcli 2.5.20260629-1 → 2.5.20260705-1

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/runner.js

@@ -45,6 +45,23 @@ const buildBuiltinKeybindings = (resolvedKeybindings) => {
     }
     return builtinKeybindings;
 };
+async function callContextHandlerAbortable(fn, signal) {
+    if (signal.aborted) {
+        throw new Error("Agent run aborted");
+    }
+    let cleanup = () => { };
+    const abortPromise = new Promise((_resolve, reject) => {
+        const onAbort = () => reject(new Error("Agent run aborted"));
+        signal.addEventListener("abort", onAbort, { once: true });
+        cleanup = () => signal.removeEventListener("abort", onAbort);
+    });
+    try {
+        return await Promise.race([Promise.resolve().then(fn), abortPromise]);
+    }
+    finally {
+        cleanup();
+    }
+}
 /**
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
@@ -358,6 +375,15 @@ export class ExtensionRunner {
         }
         return undefined;
     }
+    getEntryRenderer(customType) {
+        for (const ext of this.extensions) {
+            const renderer = ext.entryRenderers?.get(customType);
+            if (renderer) {
+                return renderer;
+            }
+        }
+        return undefined;
+    }
     resolveRegisteredCommands() {
         const commands = [];
         const counts = new Map();
@@ -684,6 +710,7 @@ export class ExtensionRunner {
     }
     async emitContext(messages) {
         const ctx = this.createContext();
+        const signal = ctx.signal;
         let currentMessages = structuredClone(messages);
         for (const ext of this.extensions) {
             const handlers = ext.handlers.get("context");
@@ -692,12 +719,17 @@ export class ExtensionRunner {
             for (const handler of handlers) {
                 try {
                     const event = { type: "context", messages: currentMessages };
-                    const handlerResult = await handler(event, ctx);
+                    const handlerResult = signal
+                        ? await callContextHandlerAbortable(() => handler(event, ctx), signal)
+                        : await handler(event, ctx);
                     if (handlerResult && handlerResult.messages) {
                         currentMessages = handlerResult.messages;
                     }
                 }
                 catch (err) {
+                    if (signal?.aborted) {
+                        throw err;
+                    }
                     const message = err instanceof Error ? err.message : String(err);
                     const stack = err instanceof Error ? err.stack : undefined;
                     this.emitError({

package/node_modules/@earendil-works/pi-coding-agent/dist/core/http-dispatcher.js

@@ -1,3 +1,4 @@
+import { EventEmitter } from "node:events";
 import * as undici from "undici";
 export const DEFAULT_HTTP_IDLE_TIMEOUT_MS = 300_000;
 export const HTTP_IDLE_TIMEOUT_CHOICES = [
@@ -39,16 +40,42 @@ export function applyHttpProxySettings(httpProxy) {
     process.env.HTTP_PROXY ??= proxy;
     process.env.HTTPS_PROXY ??= proxy;
 }
+const ignoreUndiciDispatcherError = (_error) => { };
+// Undici can emit an internal Client "error" while terminating a mid-stream
+// fetch body. The body stream still rejects through reader.read(); this listener
+// only prevents EventEmitter's unhandled "error" special case from crashing pi.
+function withUndiciErrorListener(dispatcher) {
+    if (dispatcher instanceof EventEmitter) {
+        EventEmitter.prototype.on.call(dispatcher, "error", ignoreUndiciDispatcherError);
+    }
+    return dispatcher;
+}
+function createUndiciClient(origin, options) {
+    return withUndiciErrorListener(new undici.Client(origin, options));
+}
+function createUndiciOriginDispatcher(origin, options) {
+    const dispatcherOptions = options;
+    if (dispatcherOptions.connections === 1) {
+        return createUndiciClient(origin, dispatcherOptions);
+    }
+    return withUndiciErrorListener(new undici.Pool(origin, {
+        ...dispatcherOptions,
+        factory: createUndiciClient,
+    }));
+}
 export function configureHttpDispatcher(timeoutMs = DEFAULT_HTTP_IDLE_TIMEOUT_MS) {
     const normalizedTimeoutMs = parseHttpIdleTimeoutMs(timeoutMs);
     if (normalizedTimeoutMs === undefined) {
         throw new Error(`Invalid HTTP idle timeout: ${String(timeoutMs)}`);
     }
-    undici.setGlobalDispatcher(new undici.EnvHttpProxyAgent({
+    const dispatcher = withUndiciErrorListener(new undici.EnvHttpProxyAgent({
         allowH2: false,
         bodyTimeout: normalizedTimeoutMs,
         headersTimeout: normalizedTimeoutMs,
+        clientFactory: createUndiciClient,
+        factory: createUndiciOriginDispatcher,
     }));
+    undici.setGlobalDispatcher(dispatcher);
     // Keep fetch and the dispatcher on the same undici implementation. Node 26.0's
     // bundled fetch can otherwise consume compressed responses through npm undici's
     // dispatcher without decompressing them, causing response.json() failures.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-resolver.js

@@ -195,20 +195,10 @@ export function parseModelPattern(pattern, availableModels, options) {
         return result;
     }
 }
-/**
- * Resolve model patterns to actual Model objects with optional thinking levels
- * Format: "pattern:level" where :level is optional
- * For each pattern, finds all matching models and picks the best version:
- * 1. Prefer alias (e.g., claude-sonnet-4-5) over dated versions (claude-sonnet-4-5-20250929)
- * 2. If no alias, pick the latest dated version
- *
- * Supports models with colons in their IDs (e.g., OpenRouter's model:exacto).
- * The algorithm tries to match the full pattern first, then progressively
- * strips colon-suffixes to find a match.
- */
-export async function resolveModelScope(patterns, modelRegistry) {
+export async function resolveModelScopeWithDiagnostics(patterns, modelRegistry) {
     const availableModels = await modelRegistry.getAvailable();
     const scopedModels = [];
+    const diagnostics = [];
     for (const pattern of patterns) {
         // Check if pattern contains glob characters
         if (pattern.includes("*") || pattern.includes("?") || pattern.includes("[")) {
@@ -230,7 +220,7 @@ export async function resolveModelScope(patterns, modelRegistry) {
                 return minimatch(fullId, globPattern, { nocase: true }) || minimatch(m.id, globPattern, { nocase: true });
             });
             if (matchingModels.length === 0) {
-                console.warn(chalk.yellow(`Warning: No models match pattern "${pattern}"`));
+                diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
                 continue;
             }
             for (const model of matchingModels) {
@@ -242,10 +232,10 @@ export async function resolveModelScope(patterns, modelRegistry) {
         }
         const { model, thinkingLevel, warning } = parseModelPattern(pattern, availableModels);
         if (warning) {
-            console.warn(chalk.yellow(`Warning: ${warning}`));
+            diagnostics.push({ type: "warning", message: warning, pattern });
         }
         if (!model) {
-            console.warn(chalk.yellow(`Warning: No models match pattern "${pattern}"`));
+            diagnostics.push({ type: "warning", message: `No models match pattern "${pattern}"`, pattern });
             continue;
         }
         // Avoid duplicates
@@ -253,6 +243,13 @@ export async function resolveModelScope(patterns, modelRegistry) {
             scopedModels.push({ model, thinkingLevel });
         }
     }
+    return { scopedModels, diagnostics };
+}
+export async function resolveModelScope(patterns, modelRegistry) {
+    const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics(patterns, modelRegistry);
+    for (const diagnostic of diagnostics) {
+        console.warn(chalk.yellow(`Warning: ${diagnostic.message}`));
+    }
     return scopedModels;
 }
 /**
@@ -447,10 +444,10 @@ export async function findInitialModel(options) {
             fallbackMessage: undefined,
         };
     }
-    // 3. Try saved default from settings
+    // 3. Try saved default from settings if auth is configured.
     if (defaultProvider && defaultModelId) {
         const found = modelRegistry.find(defaultProvider, defaultModelId);
-        if (found) {
+        if (found && modelRegistry.hasConfiguredAuth(found)) {
             model = found;
             if (defaultThinkingLevel) {
                 thinkingLevel = defaultThinkingLevel;

package/node_modules/@earendil-works/pi-coding-agent/dist/core/project-trust.js

@@ -2,7 +2,7 @@ import { CONFIG_DIR_NAME } from "../config.js";
 import { emitProjectTrustEvent } from "./extensions/runner.js";
 import { getProjectTrustOptions, hasTrustRequiringProjectResources, } from "./trust-manager.js";
 function formatProjectTrustPrompt(cwd) {
-    return `Trust project folder?\n${cwd}\n\nThis allows sling to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
+    return `Trust project folder?\n${cwd}\n\nThis allows pi to load ${CONFIG_DIR_NAME} settings and resources, install missing project packages, and execute project extensions.`;
 }
 async function selectProjectTrustOption(cwd, ctx) {
     const options = getProjectTrustOptions(cwd, { includeSessionOnly: true });

package/node_modules/@earendil-works/pi-coding-agent/dist/core/provider-attribution.js

@@ -4,7 +4,6 @@ const NVIDIA_NIM_HOST = "integrate.api.nvidia.com";
 const CLOUDFLARE_API_HOST = "api.cloudflare.com";
 const CLOUDFLARE_AI_GATEWAY_HOST = "gateway.ai.cloudflare.com";
 const OPENCODE_HOST = "opencode.ai";
-const VERCEL_GATEWAY_HOST = "ai-gateway.vercel.sh";
 function matchesHost(baseUrl, expectedHost) {
     try {
         return new URL(baseUrl).hostname === expectedHost;
@@ -25,9 +24,6 @@ function isCloudflareModel(model) {
         matchesHost(model.baseUrl, CLOUDFLARE_API_HOST) ||
         matchesHost(model.baseUrl, CLOUDFLARE_AI_GATEWAY_HOST));
 }
-function isVercelGatewayModel(model) {
-    return model.provider === "vercel-ai-gateway" || matchesHost(model.baseUrl, VERCEL_GATEWAY_HOST);
-}
 function getDefaultAttributionHeaders(model, settingsManager) {
     if (!isInstallTelemetryEnabled(settingsManager)) {
         return undefined;
@@ -49,12 +45,6 @@ function getDefaultAttributionHeaders(model, settingsManager) {
             "User-Agent": "pi-coding-agent",
         };
     }
-    if (isVercelGatewayModel(model)) {
-        return {
-            "http-referer": "https://pi.dev",
-            "x-title": "pi",
-        };
-    }
     return undefined;
 }
 function getSessionHeaders(model, sessionId) {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/session-manager.js

@@ -112,47 +112,40 @@ export function getLatestCompactionEntry(entries) {
     }
     return null;
 }
-/**
- * Build the session context from entries using tree traversal.
- * If leafId is provided, walks from that entry to root.
- * Handles compaction and branch summaries along the path.
- */
-export function buildSessionContext(entries, leafId, byId) {
-    // Build uuid index if not available
-    if (!byId) {
-        byId = new Map();
-        for (const entry of entries) {
-            byId.set(entry.id, entry);
-        }
+function buildEntryIndex(entries, byId) {
+    if (byId)
+        return byId;
+    const index = new Map();
+    for (const entry of entries) {
+        index.set(entry.id, entry);
     }
-    // Find leaf
+    return index;
+}
+function buildSessionPath(entries, leafId, byId) {
+    const index = buildEntryIndex(entries, byId);
     let leaf;
     if (leafId === null) {
-        // Explicitly null - return no messages (navigated to before first entry)
-        return { messages: [], thinkingLevel: "off", model: null };
+        return [];
     }
     if (leafId) {
-        leaf = byId.get(leafId);
+        leaf = index.get(leafId);
     }
+    leaf ??= entries[entries.length - 1];
     if (!leaf) {
-        // Fallback to last entry (when leafId is undefined)
-        leaf = entries[entries.length - 1];
-    }
-    if (!leaf) {
-        return { messages: [], thinkingLevel: "off", model: null };
+        return [];
     }
-    // Walk from leaf to root, collecting path
     const path = [];
     let current = leaf;
     while (current) {
         path.push(current);
-        current = current.parentId ? byId.get(current.parentId) : undefined;
+        current = current.parentId ? index.get(current.parentId) : undefined;
     }
     path.reverse();
-    // Extract settings and find compaction
+    return path;
+}
+function getSessionContextSettings(path) {
     let thinkingLevel = "off";
     let model = null;
-    let compaction = null;
     for (const entry of path) {
         if (entry.type === "thinking_level_change") {
             thinkingLevel = entry.thinkingLevel;
@@ -163,55 +156,74 @@ export function buildSessionContext(entries, leafId, byId) {
         else if (entry.type === "message" && entry.message.role === "assistant") {
             model = { provider: entry.message.provider, modelId: entry.message.model };
         }
-        else if (entry.type === "compaction") {
+    }
+    return { thinkingLevel, model };
+}
+/**
+ * Project one selected session entry into LLM/runtime messages.
+ * Plain custom entries are display/state entries and do not participate in context.
+ */
+export function sessionEntryToContextMessages(entry) {
+    if (entry.type === "message") {
+        return [entry.message];
+    }
+    if (entry.type === "custom_message") {
+        return [createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp)];
+    }
+    if (entry.type === "branch_summary" && entry.summary) {
+        return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
+    }
+    if (entry.type === "compaction") {
+        return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+    }
+    return [];
+}
+/**
+ * Build the active, compaction-aware session entry list.
+ *
+ * This follows the current leaf path. If the path contains compaction entries,
+ * the latest compaction is represented by the compaction entry itself, followed
+ * by the kept entries starting at firstKeptEntryId and all entries after the
+ * compaction entry. Older summarized entries are omitted.
+ */
+export function buildContextEntries(entries, leafId, byId) {
+    const path = buildSessionPath(entries, leafId, byId);
+    let compaction = null;
+    for (const entry of path) {
+        if (entry.type === "compaction") {
             compaction = entry;
         }
     }
-    // Build messages and collect corresponding entries
-    // When there's a compaction, we need to:
-    // 1. Emit summary first (entry = compaction)
-    // 2. Emit kept messages (from firstKeptEntryId up to compaction)
-    // 3. Emit messages after compaction
-    const messages = [];
-    const appendMessage = (entry) => {
-        if (entry.type === "message") {
-            messages.push(entry.message);
-        }
-        else if (entry.type === "custom_message") {
-            messages.push(createCustomMessage(entry.customType, entry.content, entry.display, entry.details, entry.timestamp));
-        }
-        else if (entry.type === "branch_summary" && entry.summary) {
-            messages.push(createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp));
-        }
-    };
-    if (compaction) {
-        // Emit summary first
-        messages.push(createCompactionSummaryMessage(compaction.summary, compaction.tokensBefore, compaction.timestamp));
-        // Find compaction index in path
-        const compactionIdx = path.findIndex((e) => e.type === "compaction" && e.id === compaction.id);
-        // Emit kept messages (before compaction, starting from firstKeptEntryId)
-        let foundFirstKept = false;
-        for (let i = 0; i < compactionIdx; i++) {
-            const entry = path[i];
-            if (entry.id === compaction.firstKeptEntryId) {
-                foundFirstKept = true;
-            }
-            if (foundFirstKept) {
-                appendMessage(entry);
-            }
-        }
-        // Emit messages after compaction
-        for (let i = compactionIdx + 1; i < path.length; i++) {
-            const entry = path[i];
-            appendMessage(entry);
-        }
+    if (!compaction) {
+        return path;
     }
-    else {
-        // No compaction - emit all messages, handle branch summaries and custom messages
-        for (const entry of path) {
-            appendMessage(entry);
+    const compactionIdx = path.findIndex((entry) => entry.id === compaction.id);
+    if (compactionIdx < 0) {
+        return path;
+    }
+    const contextEntries = [compaction];
+    let foundFirstKept = false;
+    for (let i = 0; i < compactionIdx; i++) {
+        const entry = path[i];
+        if (entry.id === compaction.firstKeptEntryId) {
+            foundFirstKept = true;
+        }
+        if (foundFirstKept) {
+            contextEntries.push(entry);
         }
     }
+    contextEntries.push(...path.slice(compactionIdx + 1));
+    return contextEntries;
+}
+/**
+ * Build the session context from entries using tree traversal.
+ * If leafId is provided, walks from that entry to root.
+ * Handles compaction and branch summaries along the path.
+ */
+export function buildSessionContext(entries, leafId, byId) {
+    const path = buildSessionPath(entries, leafId, byId);
+    const { thinkingLevel, model } = getSessionContextSettings(path);
+    const messages = buildContextEntries(entries, leafId, byId).flatMap(sessionEntryToContextMessages);
     return { messages, thinkingLevel, model };
 }
 /**
@@ -867,6 +879,13 @@ export class SessionManager {
         path.reverse();
         return path;
     }
+    /**
+     * Build the active, compaction-aware entry list for context/rendering.
+     * Uses tree traversal from current leaf.
+     */
+    buildContextEntries() {
+        return buildContextEntries(this.getEntries(), this.leafId, this.byId);
+    }
     /**
      * Build the session context (what gets sent to the LLM).
      * Uses tree traversal from current leaf.

package/node_modules/@earendil-works/pi-coding-agent/dist/core/settings-manager.js

@@ -862,6 +862,14 @@ export class SettingsManager {
         this.markModified("editorPaddingX");
         this.save();
     }
+    getOutputPad() {
+        return this.settings.outputPad === 0 ? 0 : 1;
+    }
+    setOutputPad(padding) {
+        this.globalSettings.outputPad = padding;
+        this.markModified("outputPad");
+        this.save();
+    }
     getAutocompleteMaxVisible() {
         return this.settings.autocompleteMaxVisible ?? 5;
     }

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/bash.js

@@ -12,6 +12,20 @@ import { OutputAccumulator } from "./output-accumulator.js";
 import { getTextOutput, invalidArgText, str } from "./render-utils.js";
 import { wrapToolDefinition } from "./tool-definition-wrapper.js";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize } from "./truncate.js";
+const MAX_TIMEOUT_MS = 2_147_483_647;
+const MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1000;
+function resolveTimeoutMs(timeout) {
+    if (timeout === undefined)
+        return undefined;
+    if (!Number.isFinite(timeout) || timeout <= 0) {
+        throw new Error("Invalid timeout: must be a finite number of seconds");
+    }
+    const timeoutMs = timeout * 1000;
+    if (timeoutMs > MAX_TIMEOUT_MS) {
+        throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+    }
+    return timeoutMs;
+}
 const bashSchema = Type.Object({
     command: Type.String({ description: "Bash command to execute" }),
     timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
@@ -25,6 +39,10 @@ const bashSchema = Type.Object({
 export function createLocalBashOperations(options) {
     return {
         exec: async (command, cwd, { onData, signal, timeout, env }) => {
+            const timeoutMs = resolveTimeoutMs(timeout);
+            if (signal?.aborted) {
+                throw new Error("aborted");
+            }
             const shellConfig = getShellConfig(options?.shellPath);
             try {
                 await fsAccess(cwd, constants.F_OK);
@@ -32,9 +50,6 @@ export function createLocalBashOperations(options) {
             catch {
                 throw new Error(`Working directory does not exist: ${cwd}\nCannot execute bash commands.`);
             }
-            if (signal?.aborted) {
-                throw new Error("aborted");
-            }
             const commandFromStdin = shellConfig.commandTransport === "stdin";
             const child = spawn(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
                 cwd,
@@ -57,12 +72,12 @@ export function createLocalBashOperations(options) {
             };
             try {
                 // Set timeout if provided.
-                if (timeout !== undefined && timeout > 0) {
+                if (timeoutMs !== undefined) {
                     timeoutHandle = setTimeout(() => {
                         timedOut = true;
                         if (child.pid)
                             killProcessTree(child.pid);
-                    }, timeout * 1000);
+                    }, timeoutMs);
                 }
                 // Stream stdout and stderr.
                 child.stdout?.on("data", onData);

package/node_modules/@earendil-works/pi-coding-agent/dist/core/tools/edit.js

@@ -13,13 +13,13 @@ const replaceEditSchema = Type.Object({
         description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call.",
     }),
     newText: Type.String({ description: "Replacement text for this targeted edit." }),
-}, { additionalProperties: false });
+}, {});
 const editSchema = Type.Object({
     path: Type.String({ description: "Path to the file to edit (relative or absolute)" }),
     edits: Type.Array(replaceEditSchema, {
         description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead.",
     }),
-}, { additionalProperties: false });
+}, {});
 const defaultEditOperations = {
     readFile: (path) => fsReadFile(path),
     writeFile: (path, content) => fsWriteFile(path, content, "utf-8"),

package/node_modules/@earendil-works/pi-coding-agent/dist/index.js

@@ -11,6 +11,7 @@ export { createEventBus } from "./core/event-bus.js";
 export { createExtensionRuntime, defineTool, discoverAndLoadExtensions, ExtensionRunner, isBashToolResult, isEditToolResult, isFindToolResult, isGrepToolResult, isLsToolResult, isReadToolResult, isToolCallEventType, isWriteToolResult, wrapRegisteredTool, wrapRegisteredTools, } from "./core/extensions/index.js";
 export { convertToLlm } from "./core/messages.js";
 export { ModelRegistry } from "./core/model-registry.js";
+export { resolveCliModel, resolveModelScopeWithDiagnostics, } from "./core/model-resolver.js";
 export { DefaultPackageManager } from "./core/package-manager.js";
 export { DefaultResourceLoader, loadProjectContextFiles } from "./core/resource-loader.js";
 // SDK for programmatic usage
@@ -19,7 +20,7 @@ export { AgentSessionRuntime,
 createAgentSession, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashTool, 
 // Tool factories (for custom cwd)
 createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, } from "./core/sdk.js";
-export { buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, migrateSessionEntries, parseSessionEntries, SessionManager, } from "./core/session-manager.js";
+export { buildContextEntries, buildSessionContext, CURRENT_SESSION_VERSION, getLatestCompactionEntry, migrateSessionEntries, parseSessionEntries, SessionManager, sessionEntryToContextMessages, } from "./core/session-manager.js";
 export { SettingsManager, } from "./core/settings-manager.js";
 // Skills
 export { formatSkillsForPrompt, loadSkills, loadSkillsFromDir, } from "./core/skills.js";

package/node_modules/@earendil-works/pi-coding-agent/dist/main.js

@@ -35,7 +35,7 @@ import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme.js"
 import { handleConfigCommand, handlePackageCommand } from "./package-manager-cli.js";
 import { isLocalPath, normalizePath, resolvePath } from "./utils/paths.js";
 import { cleanupWindowsSelfUpdateQuarantine } from "./utils/windows-self-update.js";
-const EXTENSION_LOAD_FAILURE_HINT = 'Hint: Start without extensions using "sling -ne".';
+const EXTENSION_LOAD_FAILURE_HINT = 'Hint: Start without extensions using "pi -ne".';
 /**
  * Read all content from piped stdin.
  * Returns undefined if stdin is a TTY (interactive terminal).

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/components/assistant-message.js

@@ -11,13 +11,15 @@ export class AssistantMessageComponent extends Container {
     hideThinkingBlock;
     markdownTheme;
     hiddenThinkingLabel;
+    outputPad;
     lastMessage;
     hasToolCalls = false;
-    constructor(message, hideThinkingBlock = false, markdownTheme = getMarkdownTheme(), hiddenThinkingLabel = "Thinking...") {
+    constructor(message, hideThinkingBlock = false, markdownTheme = getMarkdownTheme(), hiddenThinkingLabel = "Thinking...", outputPad = 1) {
         super();
         this.hideThinkingBlock = hideThinkingBlock;
         this.markdownTheme = markdownTheme;
         this.hiddenThinkingLabel = hiddenThinkingLabel;
+        this.outputPad = outputPad;
         // Container for text/thinking content
         this.contentContainer = new Container();
         this.addChild(this.contentContainer);
@@ -43,6 +45,12 @@ export class AssistantMessageComponent extends Container {
             this.updateContent(this.lastMessage);
         }
     }
+    setOutputPad(padding) {
+        this.outputPad = padding;
+        if (this.lastMessage) {
+            this.updateContent(this.lastMessage);
+        }
+    }
     render(width) {
         const lines = super.render(width);
         if (this.hasToolCalls || lines.length === 0) {
@@ -66,7 +74,7 @@ export class AssistantMessageComponent extends Container {
             if (content.type === "text" && content.text.trim()) {
                 // Assistant text messages with no background - trim the text
                 // Set paddingY=0 to avoid extra spacing before tool executions
-                this.contentContainer.addChild(new Markdown(content.text.trim(), 1, 0, this.markdownTheme));
+                this.contentContainer.addChild(new Markdown(content.text.trim(), this.outputPad, 0, this.markdownTheme));
             }
             else if (content.type === "thinking" && content.thinking.trim()) {
                 // Add spacing only when another visible assistant content block follows.
@@ -76,14 +84,14 @@ export class AssistantMessageComponent extends Container {
                     .some((c) => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
                 if (this.hideThinkingBlock) {
                     // Show static thinking label when hidden
-                    this.contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", this.hiddenThinkingLabel)), 1, 0));
+                    this.contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", this.hiddenThinkingLabel)), this.outputPad, 0));
                     if (hasVisibleContentAfter) {
                         this.contentContainer.addChild(new Spacer(1));
                     }
                 }
                 else {
                     // Thinking traces in thinkingText color, italic
-                    this.contentContainer.addChild(new Markdown(content.thinking.trim(), 1, 0, this.markdownTheme, {
+                    this.contentContainer.addChild(new Markdown(content.thinking.trim(), this.outputPad, 0, this.markdownTheme, {
                         color: (text) => theme.fg("thinkingText", text),
                         italic: true,
                     }));
@@ -100,7 +108,7 @@ export class AssistantMessageComponent extends Container {
         this.hasToolCalls = hasToolCalls;
         if (message.stopReason === "length") {
             this.contentContainer.addChild(new Spacer(1));
-            this.contentContainer.addChild(new Text(theme.fg("error", "Error: Model stopped because it reached the maximum output token limit. The response may be incomplete."), 1, 0));
+            this.contentContainer.addChild(new Text(theme.fg("error", "Error: Model stopped because it reached the maximum output token limit. The response may be incomplete."), this.outputPad, 0));
         }
         else if (!hasToolCalls) {
             if (message.stopReason === "aborted") {
@@ -108,12 +116,12 @@ export class AssistantMessageComponent extends Container {
                     ? message.errorMessage
                     : "Operation aborted";
                 this.contentContainer.addChild(new Spacer(1));
-                this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), 1, 0));
+                this.contentContainer.addChild(new Text(theme.fg("error", abortMessage), this.outputPad, 0));
             }
             else if (message.stopReason === "error") {
                 const errorMsg = message.errorMessage || "Unknown error";
                 this.contentContainer.addChild(new Spacer(1));
-                this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
+                this.contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), this.outputPad, 0));
             }
         }
     }