protoagent 0.1.11 → 0.1.13

package/dist/App.js

@@ -55,7 +55,7 @@ Here's how the terminal UI is laid out (showcasing all options at once for demon
 │  protoagent --session abc12345          │
 └─────────────────────────────────────────┘
 */
-import { useState, useEffect, useCallback, useRef } from 'react';
+import React, { useState, useEffect, useCallback, useRef } from 'react';
 import { Box, Text, Static, useApp, useInput, useStdout } from 'ink';
 import { LeftBar } from './components/LeftBar.js';
 import { TextInput, Select } from '@inkjs/ui';
@@ -70,18 +70,13 @@ import { createSession, ensureSystemPromptAtTop, saveSession, loadSession, gener
 import { clearTodos, getTodosForSession, setTodosForSession } from './tools/todo.js';
 import { initializeMcp, closeMcp, getConnectedMcpServers } from './mcp.js';
 import { generateSystemPrompt } from './system-prompt.js';
+import { renderFormattedText } from './utils/format-message.js';
 // ─── Scrollback helpers ───
 // These functions append text to the permanent scrollback buffer via the
 // <Static> component. Ink flushes new Static items within its own render
 // cycle, so there are no timing issues with write()/log-update.
 function printBanner(addStatic) {
-    const green = '\x1b[38;2;9;164;105m';
-    const reset = '\x1b[0m';
-    addStatic([
-        `${green}█▀█ █▀█ █▀█ ▀█▀ █▀█ ▄▀█ █▀▀ █▀▀ █▄ █ ▀█▀${reset}`,
-        `${green}█▀▀ █▀▄ █▄█  █  █▄█ █▀█ █▄█ ██▄ █ ▀█  █${reset}`,
-        '',
-    ].join('\n'));
+    addStatic(_jsxs(Text, { children: [_jsx(Text, { color: "#09A469", children: "\u2588\u2580\u2588 \u2588\u2580\u2588 \u2588\u2580\u2588 \u2580\u2588\u2580 \u2588\u2580\u2588 \u2584\u2580\u2588 \u2588\u2580\u2580 \u2588\u2580\u2580 \u2588\u2584 \u2588 \u2580\u2588\u2580" }), '\n', _jsx(Text, { color: "#09A469", children: "\u2588\u2580\u2580 \u2588\u2580\u2584 \u2588\u2584\u2588  \u2588  \u2588\u2584\u2588 \u2588\u2580\u2588 \u2588\u2584\u2588 \u2588\u2588\u2584 \u2588 \u2580\u2588  \u2588" }), '\n'] }));
 }
 function printRuntimeHeader(addStatic, config, session, dangerouslySkipPermissions) {
     const provider = getProvider(config.provider);
@@ -90,21 +85,20 @@ function printRuntimeHeader(addStatic, config, session, dangerouslySkipPermissio
         line += ' (auto-approve all)';
     if (session)
         line += ` | Session: ${session.id}`;
-    let text = `\x1b[2m${line}\x1b[0m\n`;
+    const lines = [_jsx(Text, { dimColor: true, children: line }, "model")];
     const logFilePath = logger.getLogFilePath();
     if (logFilePath) {
-        text += `\x1b[2mDebug logs: ${logFilePath}\x1b[0m\n`;
+        lines.push(_jsxs(Text, { dimColor: true, children: ["Debug logs: ", logFilePath] }, "log"));
     }
     const configPath = getActiveRuntimeConfigPath();
     if (configPath) {
-        text += `\x1b[2mConfig file: ${configPath}\x1b[0m\n`;
+        lines.push(_jsxs(Text, { dimColor: true, children: ["Config file: ", configPath] }, "config"));
     }
     const mcpServers = getConnectedMcpServers();
     if (mcpServers.length > 0) {
-        text += `\x1b[2mMCPs: ${mcpServers.join(', ')}\x1b[0m\n`;
+        lines.push(_jsxs(Text, { dimColor: true, children: ["MCPs: ", mcpServers.join(', ')] }, "mcp"));
     }
-    text += '\n';
-    addStatic(text);
+    addStatic(_jsxs(Text, { children: [lines.map((l, i) => _jsxs(React.Fragment, { children: [l, '\n'] }, i)), '\n'] }));
 }
 function normalizeTranscriptText(text) {
     const normalized = text.replace(/\r\n/g, '\n');
@@ -118,14 +112,15 @@ function normalizeTranscriptText(text) {
 function printMessageToScrollback(addStatic, role, text) {
     const normalized = normalizeTranscriptText(text);
     if (!normalized) {
-        addStatic('\n');
+        addStatic(_jsx(Text, { children: '\n' }));
         return;
     }
     if (role === 'user') {
-        addStatic(`\x1b[32m>\x1b[0m ${normalized}\n`);
+        addStatic(_jsxs(Text, { children: [_jsx(Text, { color: "green", children: '>' }), " ", normalized, '\n'] }));
         return;
     }
-    addStatic(`${normalized}\n\n`);
+    // Apply Markdown formatting (bold, italic) to assistant messages
+    addStatic(_jsxs(Text, { children: [renderFormattedText(normalized), '\n'] }));
 }
 /**
  * Format a sub-agent tool call into a human-readable activity string.
@@ -200,11 +195,11 @@ function replayMessagesToScrollback(addStatic, messages) {
         if (message.role === 'tool') {
             const toolName = msgAny.name || 'tool';
             const compact = String(msgAny.content || '').replace(/\s+/g, ' ').trim().slice(0, 180);
-            addStatic(`\x1b[2m▶ ${toolName}: ${compact}\x1b[0m\n`);
+            addStatic(_jsxs(Text, { dimColor: true, children: ['▶ ', toolName, ': ', compact, '\n'] }));
         }
     }
     if (messages.length > 0) {
-        addStatic('\n');
+        addStatic(_jsx(Text, { children: '\n' }));
     }
 }
 // Returns only the last N displayable lines of text so the live streaming box
@@ -342,10 +337,10 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
     // collisions if multiple App instances ever coexist.
     const staticCounterRef = useRef(0);
     const [staticItems, setStaticItems] = useState([]);
-    const addStatic = useCallback((text) => {
+    const addStatic = useCallback((node) => {
         staticCounterRef.current += 1;
         const id = `s${staticCounterRef.current}`;
-        setStaticItems((prev) => [...prev, { id, text }]);
+        setStaticItems((prev) => [...prev, { id, node }]);
     }, []);
     // Core state
     const [config, setConfig] = useState(null);
@@ -384,6 +379,13 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
     const assistantMessageRef = useRef(null);
     // Abort controller for cancelling the current completion
     const abortControllerRef = useRef(null);
+    // Buffer for streaming text that accumulates content and flushes complete lines to static
+    // This prevents the live streaming area from growing unbounded - complete lines are
+    // immediately flushed to <Static>, only the incomplete final line stays in the dynamic frame
+    const streamingBufferRef = useRef({
+        unflushedContent: '',
+        hasFlushedAnyLine: false,
+    });
     const didPrintIntroRef = useRef(false);
     const printedThreadErrorIdsRef = useRef(new Set());
     // ─── Post-config initialization (reused after inline setup) ───
@@ -443,7 +445,7 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
     }, [loading]);
     useEffect(() => {
         if (error) {
-            addStatic(`\x1b[31mError: ${error}\x1b[0m\n\n`);
+            addStatic(_jsxs(Text, { color: "red", children: ["Error: ", error] }));
         }
     }, [error, addStatic]);
     useEffect(() => {
@@ -452,7 +454,7 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
                 continue;
             }
             printedThreadErrorIdsRef.current.add(threadError.id);
-            addStatic(`\x1b[31mError: ${threadError.message}\x1b[0m\n\n`);
+            addStatic(_jsxs(Text, { color: "red", children: ["Error: ", threadError.message] }));
         }
     }, [threadErrors, addStatic]);
     useEffect(() => {
@@ -556,8 +558,9 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
         setError(null);
         setHelpMessage(null);
         setThreadErrors([]);
-        // Reset turn tracking
+        // Reset turn tracking and streaming buffer
         assistantMessageRef.current = null;
+        streamingBufferRef.current = { unflushedContent: '', hasFlushedAnyLine: false };
         // Print the user message directly to scrollback so it is selectable/copyable.
         // We still push it into completionMessages for session saving.
         const userMessage = { role: 'user', content: trimmed };
@@ -573,23 +576,56 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
             const updatedMessages = await runAgenticLoop(clientRef.current, config.model, [...completionMessages, userMessage], trimmed, (event) => {
                 switch (event.type) {
                     case 'text_delta': {
-                        // Accumulate tokens into streamingText React state — shown live in
-                        // the dynamic Ink frame. The frame height stays constant (spinner +
-                        // streaming box + input) so setState here does NOT trigger
-                        // clearTerminal. At 'done' the full text is flushed to <Static>.
+                        const deltaText = event.content || '';
+                        // First text delta of this turn: initialize ref, show streaming indicator.
                         if (!assistantMessageRef.current || assistantMessageRef.current.kind !== 'streaming_text') {
-                            // First text delta of this turn: initialise ref, show streaming indicator.
-                            const assistantMsg = { role: 'assistant', content: event.content || '', tool_calls: [] };
+                            // Trim leading whitespace from first delta - LLMs often output leading \n or spaces
+                            const trimmedDelta = deltaText.replace(/^\s+/, '');
+                            const assistantMsg = { role: 'assistant', content: trimmedDelta, tool_calls: [] };
                             const idx = completionMessages.length + 1;
                             assistantMessageRef.current = { message: assistantMsg, index: idx, kind: 'streaming_text' };
                             setIsStreaming(true);
-                            setStreamingText(event.content || '');
                             setCompletionMessages((prev) => [...prev, assistantMsg]);
+                            // Initialize the streaming buffer and process the first chunk
+                            // through the same split logic as subsequent deltas for consistency
+                            const buffer = { unflushedContent: trimmedDelta, hasFlushedAnyLine: false };
+                            streamingBufferRef.current = buffer;
+                            // Process the first chunk: split on newlines and flush complete lines
+                            const lines = buffer.unflushedContent.split('\n');
+                            if (lines.length > 1) {
+                                const completeLines = lines.slice(0, -1);
+                                const textToFlush = completeLines.join('\n');
+                                if (textToFlush) {
+                                    addStatic(renderFormattedText(textToFlush));
+                                    buffer.hasFlushedAnyLine = true;
+                                }
+                                buffer.unflushedContent = lines[lines.length - 1];
+                            }
+                            setStreamingText(buffer.unflushedContent);
                         }
                         else {
-                            // Subsequent deltas — append to ref AND to React state for live display.
-                            assistantMessageRef.current.message.content += event.content || '';
-                            setStreamingText((prev) => prev + (event.content || ''));
+                            // Subsequent deltas — append to ref and buffer, then flush complete lines
+                            assistantMessageRef.current.message.content += deltaText;
+                            // Accumulate in buffer and flush complete lines to static
+                            const buffer = streamingBufferRef.current;
+                            buffer.unflushedContent += deltaText;
+                            // Split on newlines to find complete lines
+                            const lines = buffer.unflushedContent.split('\n');
+                            // If we have more than 1 element, there were newlines
+                            if (lines.length > 1) {
+                                // All lines except the last one are complete (ended with \n)
+                                const completeLines = lines.slice(0, -1);
+                                // Build the text to flush - each complete line gets a newline added back
+                                const textToFlush = completeLines.join('\n');
+                                if (textToFlush) {
+                                    addStatic(renderFormattedText(textToFlush));
+                                    buffer.hasFlushedAnyLine = true;
+                                }
+                                // Keep only the last (incomplete) line in the buffer
+                                buffer.unflushedContent = lines[lines.length - 1];
+                            }
+                            // Show the incomplete line (if any) in the dynamic frame
+                            setStreamingText(buffer.unflushedContent);
                         }
                         break;
                     }
@@ -613,14 +649,19 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
                             const toolCall = event.toolCall;
                             setActiveTool(toolCall.name);
                             // If the model streamed some text before invoking this tool,
-                            // flush it to <Static> now. Without this, streamingText is
-                            // never cleared — the 'done' handler only flushes streaming_text
-                            // when the turn ends with plain text, not with tool calls.
+                            // flush any remaining unflushed content to <Static> now.
+                            // The streaming buffer contains text that hasn't been flushed yet
+                            // (the incomplete final line). We need to flush it before the tool call.
                             if (assistantMessageRef.current?.kind === 'streaming_text') {
-                                const precedingText = assistantMessageRef.current.message.content || '';
-                                if (precedingText) {
-                                    addStatic(`${normalizeTranscriptText(precedingText)}\n\n`);
+                                const buffer = streamingBufferRef.current;
+                                // Flush any remaining unflushed content
+                                if (buffer.unflushedContent) {
+                                    addStatic(renderFormattedText(buffer.unflushedContent));
                                 }
+                                // Add spacing after the streamed text and before the tool call
+                                addStatic(renderFormattedText('\n'));
+                                // Reset streaming state and buffer
+                                streamingBufferRef.current = { unflushedContent: '', hasFlushedAnyLine: false };
                                 setIsStreaming(false);
                                 setStreamingText('');
                                 assistantMessageRef.current = null;
@@ -679,7 +720,7 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
                                 .replace(/\s+/g, ' ')
                                 .trim()
                                 .slice(0, 180);
-                            addStatic(`\x1b[2m▶ ${toolCall.name}: ${compactResult}\x1b[0m\n`);
+                            addStatic(_jsxs(Text, { dimColor: true, children: ['▶ ', toolCall.name, ': ', compactResult, '\n'] }));
                             // Flush the assistant message + tool result into completionMessages
                             // for session saving.
                             setCompletionMessages((prev) => {
@@ -746,14 +787,32 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
                     case 'done':
                         if (assistantMessageRef.current?.kind === 'streaming_text') {
                             const finalRef = assistantMessageRef.current;
-                            // Flush the complete streamed text to <Static> (permanent scrollback),
-                            // then clear the live streaming state from the dynamic Ink frame.
-                            const normalized = normalizeTranscriptText(finalRef.message.content || '');
-                            if (normalized) {
-                                addStatic(`${normalized}\n\n`);
+                            const buffer = streamingBufferRef.current;
+                            // Flush any remaining unflushed content from the buffer
+                            // This is the final incomplete line that was being displayed live
+                            if (buffer.unflushedContent) {
+                                // If we've already flushed some lines, just append the remainder
+                                // Otherwise, normalize and flush the full content
+                                if (buffer.hasFlushedAnyLine) {
+                                    addStatic(renderFormattedText(buffer.unflushedContent));
+                                }
+                                else {
+                                    // Nothing was flushed yet, normalize the full content
+                                    const normalized = normalizeTranscriptText(finalRef.message.content || '');
+                                    if (normalized) {
+                                        addStatic(renderFormattedText(normalized));
+                                    }
+                                }
+                            }
+                            // Add final spacing after the streamed text
+                            // Always add one newline - the user message adds another for blank line separation
+                            if (buffer.unflushedContent) {
+                                addStatic(renderFormattedText('\n'));
                             }
+                            // Clear streaming state and buffer
                             setIsStreaming(false);
                             setStreamingText('');
+                            streamingBufferRef.current = { unflushedContent: '', hasFlushedAnyLine: false };
                             setCompletionMessages((prev) => {
                                 const updated = [...prev];
                                 updated[finalRef.index] = { ...finalRef.message };
@@ -799,11 +858,11 @@ export const App = ({ dangerouslySkipPermissions = false, logLevel, sessionId, }
         }
     });
     // ─── Render ───
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticItems, children: (item) => (_jsx(Text, { children: item.text }, item.id)) }), helpMessage && (_jsx(LeftBar, { color: "green", marginTop: 1, marginBottom: 1, children: _jsx(Text, { children: helpMessage }) })), !initialized && !error && !needsSetup && _jsx(Text, { children: "Initializing..." }), needsSetup && (_jsx(InlineSetup, { onComplete: (newConfig) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: staticItems, children: (item) => (_jsx(Text, { children: item.node }, item.id)) }), helpMessage && (_jsx(LeftBar, { color: "green", marginTop: 1, marginBottom: 1, children: _jsx(Text, { children: helpMessage }) })), !initialized && !error && !needsSetup && _jsx(Text, { children: "Initializing..." }), needsSetup && (_jsx(InlineSetup, { onComplete: (newConfig) => {
                     initializeWithConfig(newConfig).catch((err) => {
                         setError(`Initialization failed: ${err.message}`);
                     });
-                } })), isStreaming && (_jsxs(Text, { wrap: "wrap", children: [clipToRows(streamingText, terminalRows), _jsx(Text, { dimColor: true, children: "\u258D" })] })), threadErrors.filter((threadError) => threadError.transient).map((threadError) => (_jsx(LeftBar, { color: "gray", marginBottom: 1, children: _jsx(Text, { color: "gray", children: threadError.message }) }, `thread-error-${threadError.id}`))), pendingApproval && (_jsx(ApprovalPrompt, { request: pendingApproval.request, onRespond: (response) => {
+                } })), isStreaming && (_jsxs(Text, { wrap: "wrap", children: [renderFormattedText(clipToRows(streamingText, terminalRows)), _jsx(Text, { dimColor: true, children: "\u258D" })] })), threadErrors.filter((threadError) => threadError.transient).map((threadError) => (_jsx(LeftBar, { color: "gray", marginBottom: 1, children: _jsx(Text, { color: "gray", children: threadError.message }) }, `thread-error-${threadError.id}`))), pendingApproval && (_jsx(ApprovalPrompt, { request: pendingApproval.request, onRespond: (response) => {
                     pendingApproval.resolve(response);
                     setPendingApproval(null);
                 } })), initialized && !pendingApproval && loading && !isStreaming && (_jsx(Box, { children: _jsxs(Text, { color: "green", bold: true, children: [SPINNER_FRAMES[spinnerFrame], ' ', activeTool ? `Running ${activeTool}...` : 'Working...'] }) })), initialized && !pendingApproval && inputText.startsWith('/') && (_jsx(CommandFilter, { inputText: inputText })), _jsx(UsageDisplay, { usage: lastUsage ?? null, totalCost: totalCost }), initialized && !pendingApproval && (_jsx(Box, { children: _jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: "green", bold: true, children: '>' }) }), _jsx(Box, { flexGrow: 1, minWidth: 10, children: _jsx(TextInput, { defaultValue: inputText, onChange: setInputText, placeholder: "Type your message... (/help for commands)", onSubmit: handleSubmit }, inputResetKey) })] }) })), quittingSession && (_jsxs(Box, { flexDirection: "column", marginTop: 1, paddingX: 1, marginBottom: 1, children: [_jsx(Text, { dimColor: true, children: "Session saved. Resume with:" }), _jsxs(Text, { color: "green", children: ["protoagent --session ", quittingSession.id] })] }))] }));

package/dist/agentic-loop.js

@@ -281,8 +281,10 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
     let contextRetryCount = 0;
     let retriggerCount = 0;
     let truncateRetryCount = 0;
+    let continueRetryCount = 0;
     const MAX_RETRIGGERS = 3;
     const MAX_TRUNCATE_RETRIES = 5;
+    const MAX_CONTINUE_RETRIES = 1;
     const validToolNames = getValidToolNames();
     while (iterationCount < maxIterations) {
         // Check if abort was requested
@@ -714,6 +716,21 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
                         continue;
                     }
                 }
+                // After truncation retries exhausted, try adding a "continue" message
+                if (continueRetryCount < MAX_CONTINUE_RETRIES) {
+                    continueRetryCount++;
+                    updatedMessages.push({ role: 'user', content: 'continue' });
+                    logger.warn('400 error: adding "continue" message to retry', {
+                        continueRetryCount,
+                        messageCount: updatedMessages.length,
+                    });
+                    onEvent({
+                        type: 'error',
+                        error: 'Request failed. Retrying with "continue"...',
+                        transient: true,
+                    });
+                    continue;
+                }
             }
             // Handle context-window-exceeded (prompt too long) — attempt forced compaction
             // This fires when our token estimate was too low (e.g. base64 images from MCP tools)
@@ -778,7 +795,7 @@ export async function runAgenticLoop(client, model, messages, userInput, onEvent
             if (apiError?.status === 400) {
                 onEvent({
                     type: 'error',
-                    error: 'The conversation history appears to be corrupted and could not be automatically repaired. Try /clear to start fresh.',
+                    error: `Request failed: ${errMsg}\n\nThe conversation history could not be automatically repaired. Try /clear to start fresh.`,
                     transient: false,
                 });
                 onEvent({ type: 'done' });

package/dist/components/FormattedMessage.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { formatMessage } from '../utils/format-message.js';
+import { renderFormattedText } from '../utils/format-message.js';
 import { LeftBar } from './LeftBar.js';
 export const DEFERRED_TABLE_PLACEHOLDER = 'table loading';
 const graphemeSegmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
@@ -165,6 +165,6 @@ export const FormattedMessage = ({ content, deferTables = false }) => {
             // Text Block
             if (!block.content.trim())
                 return null;
-            return (_jsx(Box, { marginBottom: 0, children: _jsx(Text, { children: formatMessage(block.content) }) }, index));
+            return (_jsx(Box, { marginBottom: 0, children: _jsx(Text, { children: renderFormattedText(block.content) }) }, index));
         }) }));
 };

package/dist/system-prompt.js

@@ -130,7 +130,8 @@ GUIDELINES
 
 OUTPUT FORMAT:
 - You are running in a terminal. Be concise. Optimise for scannability.
-- Do NOT use Markdown formatting. No **bold**, no *italic*, no # headers, no --- dividers.
+- Use **bold** and *italic* formatting tastefully to highlight key points and structure your responses.
+- Do NOT use # headers, --- dividers, or other structural Markdown.
 - Do NOT use Markdown code fences (backticks) unless the content is actual code or a command.
 - For structured data, use plain text with aligned columns (spaces, not pipes/dashes).
 - Keep tables compact: narrower columns, minimal padding. Wrap cell content rather than making very wide tables.

package/dist/utils/format-message.js

@@ -1,26 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+function parseSegments(text) {
+    const segments = [];
+    // Strip markdown headers
+    const cleaned = text.replace(/^#+\s+/gm, '');
+    // Pattern to match ***bold italic***, **bold**, *italic*
+    const pattern = /(\*\*\*[^*]+?\*\*\*|\*\*[^*]+?\*\*|\*[^\s*][^*]*?\*)/g;
+    let lastIndex = 0;
+    let match;
+    while ((match = pattern.exec(cleaned)) !== null) {
+        // Add plain text before match
+        if (match.index > lastIndex) {
+            segments.push({ text: cleaned.slice(lastIndex, match.index) });
+        }
+        const fullMatch = match[0];
+        let content;
+        let bold = false;
+        let italic = false;
+        if (fullMatch.startsWith('***')) {
+            content = fullMatch.slice(3, -3);
+            bold = true;
+            italic = true;
+        }
+        else if (fullMatch.startsWith('**')) {
+            content = fullMatch.slice(2, -2);
+            bold = true;
+        }
+        else {
+            content = fullMatch.slice(1, -1);
+            italic = true;
+        }
+        segments.push({ text: content, bold, italic });
+        lastIndex = pattern.lastIndex;
+    }
+    // Add remaining plain text
+    if (lastIndex < cleaned.length) {
+        segments.push({ text: cleaned.slice(lastIndex) });
+    }
+    return segments.length > 0 ? segments : [{ text: cleaned }];
+}
 /**
- * Parse Markdown-style formatting and convert to ANSI escape codes.
- *
- * Supports:
- * - **bold** → bold text
- * - *italic* → italic text
- * - ***bold italic*** → bold + italic text
- *
- * Returns a string with ANSI escape codes that Ink will render with styling.
+ * Render formatted text as Ink Text elements.
+ * Returns an array of <Text> components that can be nested inside a parent <Text>.
  */
-export function formatMessage(text) {
-    // ANSI escape codes for styling
-    const BOLD = '\x1b[1m';
-    const ITALIC = '\x1b[3m';
-    const RESET = '\x1b[0m';
-    let result = text;
-    // Strip markdown hashtags (headers)
-    result = result.replace(/^#+\s+/gm, '');
-    // Replace ***bold italic*** first (to avoid matching ** or * inside)
-    result = result.replace(/\*\*\*(.+?)\*\*\*/g, `${BOLD}${ITALIC}$1${RESET}`);
-    // Replace **bold**
-    result = result.replace(/\*\*(.+?)\*\*/g, `${BOLD}$1${RESET}`);
-    // Replace *italic*
-    result = result.replace(/\*(.+?)\*/g, `${ITALIC}$1${RESET}`);
-    return result;
+export function renderFormattedText(text) {
+    const segments = parseSegments(text);
+    if (segments.length === 1 && !segments[0].bold && !segments[0].italic) {
+        return segments[0].text;
+    }
+    return segments.map((seg, i) => (_jsx(Text, { bold: seg.bold, italic: seg.italic, children: seg.text }, i)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protoagent",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "files": [
     "dist",