@datalayer/agent-runtimes 0.0.7 → 0.0.8

package/lib/components/chat/components/display/ToolCallDisplay.js

@@ -12,11 +12,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Text, Spinner } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
-import { ChevronDownIcon, ChevronRightIcon, ToolsIcon, CheckCircleIcon, XCircleIcon, ClockIcon, } from '@primer/octicons-react';
+import { ChevronDownIcon, ChevronRightIcon, ToolsIcon, CheckCircleIcon, XCircleIcon, ClockIcon, AlertIcon, } from '@primer/octicons-react';
 /**
  * Get status icon and color based on tool call status
  */
-function getStatusDisplay(status) {
+function getStatusDisplay(status, errorType) {
     switch (status) {
         case 'inProgress':
             return {
@@ -40,6 +40,31 @@ function getStatusDisplay(status) {
                 bgColor: 'success.subtle',
             };
         case 'error':
+            // Distinguish between execution errors, code errors, and exit codes
+            if (errorType === 'execution') {
+                return {
+                    icon: _jsx(AlertIcon, { size: 14 }),
+                    color: 'danger.fg',
+                    label: 'Execution Failed',
+                    bgColor: 'danger.subtle',
+                };
+            }
+            else if (errorType === 'code') {
+                return {
+                    icon: _jsx(XCircleIcon, { size: 14 }),
+                    color: 'severe.fg',
+                    label: 'Code Error',
+                    bgColor: 'severe.subtle',
+                };
+            }
+            else if (errorType === 'exit') {
+                return {
+                    icon: _jsx(AlertIcon, { size: 14 }),
+                    color: 'attention.fg',
+                    label: 'Exited',
+                    bgColor: 'attention.subtle',
+                };
+            }
             return {
                 icon: _jsx(XCircleIcon, { size: 14 }),
                 color: 'danger.fg',
@@ -97,12 +122,41 @@ function getArgsSummary(args) {
  * - Shows tool name, status icon, and brief summary when collapsed
  * - Expands to show full parameters and results
  * - Color-coded status indicators
+ * - Rich error display distinguishing execution errors from code errors
  */
-export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, }) {
+export function ToolCallDisplay({ toolCallId, toolName, args, result, status, error, executionResult, codeError, exitCode, executionError, }) {
     const [isExpanded, setIsExpanded] = useState(false);
-    const statusDisplay = getStatusDisplay(status);
+    // Determine effective exit code from props or execution result
+    const effectiveExitCode = exitCode ?? executionResult?.exit_code;
+    const hasNonZeroExit = effectiveExitCode != null && effectiveExitCode !== 0;
+    // Determine error type for status display
+    // Priority: execution error > code error > non-zero exit code
+    const errorType = status === 'error'
+        ? executionError || executionResult?.execution_error
+            ? 'execution'
+            : codeError || executionResult?.code_error
+                ? 'code'
+                : hasNonZeroExit
+                    ? 'exit'
+                    : 'unknown'
+        : undefined;
+    const statusDisplay = getStatusDisplay(status, errorType);
     const displayName = formatToolName(toolName);
     const argsSummary = getArgsSummary(args);
+    // Get error details from various sources (prefer rich error info)
+    const effectiveCodeError = codeError || executionResult?.code_error || undefined;
+    const effectiveExecutionError = executionError || executionResult?.execution_error || undefined;
+    const effectiveError = error || executionResult?.error || effectiveExecutionError || undefined;
+    const exitOutput = executionResult?.output;
+    const effectiveExitOutput = exitOutput ??
+        (typeof result === 'string'
+            ? result
+            : result != null && typeof result === 'object'
+                ? (result.output ??
+                    result.stdout ??
+                    result.stderr ??
+                    undefined)
+                : undefined);
     return (_jsxs(Box, { sx: {
             width: '100%',
             border: '1px solid',
@@ -201,7 +255,58 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
                                         wordBreak: 'break-word',
                                     }, children: typeof result === 'string'
                                         ? result
-                                        : JSON.stringify(result, null, 2) }) })] })), status === 'error' && error && (_jsxs(Box, { children: [_jsx(Text, { sx: {
+                                        : JSON.stringify(result, null, 2) }) })] })), status === 'error' && effectiveExecutionError && (_jsxs(Box, { children: [_jsxs(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'danger.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    mb: 2,
+                                }, children: [_jsx(AlertIcon, { size: 12 }), " Execution Error"] }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'danger.subtle',
+                                    borderRadius: 2,
+                                    border: '1px solid',
+                                    borderColor: 'danger.muted',
+                                    p: 2,
+                                }, children: [_jsx(Text, { sx: { fontSize: 1, color: 'danger.fg' }, children: effectiveExecutionError }), _jsx(Text, { sx: {
+                                            display: 'block',
+                                            fontSize: 0,
+                                            color: 'fg.muted',
+                                            mt: 1,
+                                        }, children: "The sandbox or execution environment failed to run the code." })] })] })), status === 'error' && effectiveCodeError && (_jsxs(Box, { children: [_jsxs(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'severe.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    mb: 2,
+                                }, children: ["Code Error: ", effectiveCodeError.name] }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'severe.subtle',
+                                    borderRadius: 2,
+                                    border: '1px solid',
+                                    borderColor: 'severe.muted',
+                                    overflow: 'hidden',
+                                }, children: [_jsx(Box, { sx: { p: 2 }, children: _jsx(Text, { sx: { fontSize: 1, color: 'severe.fg' }, children: effectiveCodeError.value }) }), effectiveCodeError.traceback && (_jsx(Box, { sx: {
+                                            borderTop: '1px solid',
+                                            borderColor: 'severe.muted',
+                                            backgroundColor: 'canvas.inset',
+                                        }, children: _jsx("pre", { style: {
+                                                margin: 0,
+                                                padding: '8px 12px',
+                                                fontSize: '11px',
+                                                fontFamily: 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace',
+                                                lineHeight: 1.4,
+                                                whiteSpace: 'pre-wrap',
+                                                wordBreak: 'break-word',
+                                                maxHeight: '200px',
+                                                overflow: 'auto',
+                                            }, children: effectiveCodeError.traceback }) }))] })] })), status === 'error' &&
+                        effectiveError &&
+                        !effectiveExecutionError &&
+                        !effectiveCodeError &&
+                        !hasNonZeroExit && (_jsxs(Box, { children: [_jsx(Text, { sx: {
                                     display: 'block',
                                     fontSize: 0,
                                     fontWeight: 'semibold',
@@ -215,7 +320,44 @@ export function ToolCallDisplay({ toolCallId, toolName, args, result, status, er
                                     border: '1px solid',
                                     borderColor: 'danger.muted',
                                     p: 2,
-                                }, children: _jsx(Text, { sx: { fontSize: 1, color: 'danger.fg' }, children: error }) })] })), _jsx(Box, { sx: {
+                                }, children: _jsx(Text, { sx: { fontSize: 1, color: 'danger.fg' }, children: effectiveError }) })] })), hasNonZeroExit &&
+                        !effectiveExecutionError &&
+                        !effectiveCodeError && (_jsxs(Box, { children: [_jsxs(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'attention.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    mb: 2,
+                                }, children: [_jsx(AlertIcon, { size: 12 }), " Process Exited"] }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'attention.subtle',
+                                    borderRadius: 2,
+                                    border: '1px solid',
+                                    borderColor: 'attention.muted',
+                                    p: 2,
+                                }, children: [_jsxs(Text, { sx: { fontSize: 1, color: 'attention.fg' }, children: ["Process exited with code ", effectiveExitCode] }), _jsx(Text, { sx: {
+                                            display: 'block',
+                                            fontSize: 0,
+                                            color: 'fg.muted',
+                                            mt: 1,
+                                        }, children: "The code called sys.exit() with a non-zero exit code." })] }), effectiveExitOutput && (_jsx(Box, { sx: {
+                                    mt: 2,
+                                    backgroundColor: 'canvas.inset',
+                                    borderRadius: 2,
+                                    border: '1px solid',
+                                    borderColor: 'attention.muted',
+                                    overflow: 'auto',
+                                }, children: _jsx("pre", { style: {
+                                        margin: 0,
+                                        padding: '10px 12px',
+                                        fontSize: '12px',
+                                        fontFamily: 'ui-monospace, SFMono-Regular, "SF Mono", Menlo, Consolas, monospace',
+                                        lineHeight: 1.4,
+                                        whiteSpace: 'pre-wrap',
+                                        wordBreak: 'break-word',
+                                        maxHeight: '200px',
+                                    }, children: effectiveExitOutput }) }))] })), _jsx(Box, { sx: {
                             mt: 3,
                             pt: 2,
                             borderTop: '1px solid',

package/lib/components/chat/components/display/index.d.ts

@@ -3,4 +3,4 @@
  *
  * @module components/chat/components/display
  */
-export { ToolCallDisplay, type ToolCallDisplayProps } from './ToolCallDisplay';
+export { ToolCallDisplay, type ToolCallDisplayProps, type ErrorType, } from './ToolCallDisplay';

package/lib/components/chat/components/display/index.js

@@ -7,4 +7,4 @@
  *
  * @module components/chat/components/display
  */
-export { ToolCallDisplay } from './ToolCallDisplay';
+export { ToolCallDisplay, } from './ToolCallDisplay';

package/lib/components/chat/components/elements/ChatInputPrompt.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Chat input component.
+ * Provides the message input area with send button and optional tool suggestions.
+ *
+ * @module components/chat/components/elements/ChatInputPrompt
+ */
+import React from 'react';
 /**
  * ChatInputPrompt props
  */
@@ -14,6 +21,10 @@ export interface ChatInputPromptProps {
     maxRows?: number;
     /** Custom class name */
     className?: string;
+    /** Leading icon to display on the left of the input */
+    leadingIcon?: React.ReactNode;
+    /** Custom send button text */
+    sendButtonText?: string;
     /** Callback before sending */
     onBeforeSend?: (content: string) => boolean | void;
     /** Callback after sending */
@@ -22,5 +33,5 @@ export interface ChatInputPromptProps {
 /**
  * Chat Input Prompt component
  */
-export declare function ChatInputPrompt({ placeholder, disabled, showToolSuggestions, showFileUpload, maxRows, className, onBeforeSend, onAfterSend, }: ChatInputPromptProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChatInputPrompt({ placeholder, disabled, showToolSuggestions, showFileUpload, maxRows, className, leadingIcon, sendButtonText, onBeforeSend, onAfterSend, }: ChatInputPromptProps): import("react/jsx-runtime").JSX.Element;
 export default ChatInputPrompt;

package/lib/components/chat/components/elements/ChatInputPrompt.js

@@ -18,7 +18,7 @@ import { useChatStreaming, useChatTools } from '../../store/chatStore';
 /**
  * Chat Input Prompt component
  */
-export function ChatInputPrompt({ placeholder = 'Type a message...', disabled = false, showToolSuggestions = true, showFileUpload = false, maxRows = 6, className, onBeforeSend, onAfterSend, }) {
+export function ChatInputPrompt({ placeholder = 'Type a message...', disabled = false, showToolSuggestions = true, showFileUpload = false, maxRows = 6, className, leadingIcon, sendButtonText = 'Send', onBeforeSend, onAfterSend, }) {
     const [input, setInput] = useState('');
     const [showSuggestions, setShowSuggestions] = useState(false);
     const textareaRef = useRef(null);
@@ -133,13 +133,18 @@ export function ChatInputPrompt({ placeholder = 'Type a message...', disabled =
                     borderRadius: 2,
                     boxShadow: 'shadow.large',
                     zIndex: 10,
-                }, children: _jsx(ActionList, { children: filteredTools.map(tool => (_jsxs(ActionList.Item, { onSelect: () => handleToolMention(tool.name), children: [_jsx(ActionList.LeadingVisual, { children: _jsx(MentionIcon, {}) }), _jsxs(Box, { children: [_jsx(Box, { sx: { fontWeight: 'semibold' }, children: tool.name }), tool.description && (_jsx(Box, { sx: { fontSize: 0, color: 'fg.muted' }, children: tool.description }))] })] }, tool.name))) }) })), _jsxs(Box, { sx: { display: 'flex', gap: 2, alignItems: 'flex-end' }, children: [showFileUpload && (_jsx(IconButton, { icon: UploadIcon, "aria-label": "Upload file", variant: "invisible", disabled: disabled || !!isStreaming })), _jsx(Box, { sx: { flex: 1 }, children: _jsx(Textarea, { ref: textareaRef, value: input, onChange: e => setInput(e.target.value), onKeyDown: handleKeyDown, onBlur: () => setTimeout(() => setShowSuggestions(false), 200), placeholder: placeholder, disabled: disabled || !!isStreaming, rows: 1, sx: {
+                }, children: _jsx(ActionList, { children: filteredTools.map(tool => (_jsxs(ActionList.Item, { onSelect: () => handleToolMention(tool.name), children: [_jsx(ActionList.LeadingVisual, { children: _jsx(MentionIcon, {}) }), _jsxs(Box, { children: [_jsx(Box, { sx: { fontWeight: 'semibold' }, children: tool.name }), tool.description && (_jsx(Box, { sx: { fontSize: 0, color: 'fg.muted' }, children: tool.description }))] })] }, tool.name))) }) })), _jsxs(Box, { sx: { display: 'flex', gap: 2, alignItems: 'flex-end' }, children: [leadingIcon && (_jsx(Box, { sx: {
+                            display: 'flex',
+                            alignItems: 'center',
+                            color: 'fg.muted',
+                            pb: 2,
+                        }, children: leadingIcon })), showFileUpload && (_jsx(IconButton, { icon: UploadIcon, "aria-label": "Upload file", variant: "invisible", disabled: disabled || !!isStreaming })), _jsx(Box, { sx: { flex: 1 }, children: _jsx(Textarea, { ref: textareaRef, value: input, onChange: e => setInput(e.target.value), onKeyDown: handleKeyDown, onBlur: () => setTimeout(() => setShowSuggestions(false), 200), placeholder: placeholder, disabled: disabled || !!isStreaming, rows: 1, sx: {
                                 width: '100%',
                                 maxHeight: `${maxRows * 24}px`,
                                 minHeight: '40px',
                                 resize: 'none',
                                 overflow: 'hidden',
                                 transition: 'height 0.1s ease-out',
-                            } }) }), isStreaming ? (_jsx(Button, { variant: "danger", onClick: handleStop, leadingVisual: SquareCircleIcon, "aria-label": "Stop generation", children: "Stop" })) : (_jsx(Button, { variant: "primary", onClick: handleSend, disabled: disabled || !input.trim(), leadingVisual: PaperAirplaneIcon, "aria-label": "Send message", children: "Send" }))] }), _jsxs(Box, { sx: { fontSize: 0, color: 'fg.muted' }, children: ["Press ", _jsx("kbd", { children: "Enter" }), " to send, ", _jsx("kbd", { children: "Shift+Enter" }), " for new line", showToolSuggestions && ', @ to mention tools'] })] }));
+                            } }) }), isStreaming ? (_jsx(Button, { variant: "danger", onClick: handleStop, leadingVisual: SquareCircleIcon, "aria-label": "Stop generation", children: "Stop" })) : (_jsx(Button, { variant: "primary", onClick: handleSend, disabled: disabled || !input.trim(), leadingVisual: PaperAirplaneIcon, "aria-label": "Send message", children: sendButtonText }))] }), _jsxs(Box, { sx: { fontSize: 0, color: 'fg.muted' }, children: ["Press ", _jsx("kbd", { children: "Enter" }), " to send, ", _jsx("kbd", { children: "Shift+Enter" }), " for new line", showToolSuggestions && ', @ to mention tools'] })] }));
 }
 export default ChatInputPrompt;

package/lib/components/chat/components/index.d.ts

@@ -9,6 +9,7 @@ export { ChatSidebar, type ChatSidebarProps } from './ChatSidebar';
 export { ChatStandalone, type ChatStandaloneProps, type MessageHandler, } from './ChatStandalone';
 export { ChatBase, type ChatBaseProps, type ProtocolConfig, } from './base/ChatBase';
 export { AgentDetails, type AgentDetailsProps } from './AgentDetails';
+export { AgentIdentity, IdentityCard, getTokenStatus, formatDuration, formatExpirationStatus, type AgentIdentityProps, type IdentityCardProps, type TokenStatus, } from './AgentIdentity';
 export { ContextUsage, type ContextUsageProps, type ContextDetailsResponse, } from './ContextUsage';
 export { ContextDistribution, type ContextDistributionProps, type ContextSnapshotResponse, } from './ContextDistribution';
 export { ToolApprovalDialog, useToolApprovalDialog, type ToolApprovalDialogProps, } from './elements/ToolApprovalDialog';

package/lib/components/chat/components/index.js

@@ -13,6 +13,7 @@ export { ChatSidebar } from './ChatSidebar';
 export { ChatStandalone, } from './ChatStandalone';
 export { ChatBase, } from './base/ChatBase';
 export { AgentDetails } from './AgentDetails';
+export { AgentIdentity, IdentityCard, getTokenStatus, formatDuration, formatExpirationStatus, } from './AgentIdentity';
 export { ContextUsage, } from './ContextUsage';
 export { ContextDistribution, } from './ContextDistribution';
 export { ToolApprovalDialog, useToolApprovalDialog, } from './elements/ToolApprovalDialog';

package/lib/components/chat/components/parts/ToolPart.d.ts

@@ -11,7 +11,7 @@ export interface ToolPartProps {
  * - Status indicator (pending, running, completed, error)
  * - JSON display for input parameters
  * - JSON display for output/result
- * - Error highlighting
+ * - Rich error display with execution vs code error distinction
  */
 export declare function ToolPart({ part }: ToolPartProps): import("react/jsx-runtime").JSX.Element;
 export default ToolPart;

package/lib/components/chat/components/parts/ToolPart.js

@@ -12,11 +12,44 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from 'react';
 import { Text, Button } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
-import { ChevronDownIcon } from '@primer/octicons-react';
+import { ChevronDownIcon, AlertIcon } from '@primer/octicons-react';
+/**
+ * Check if output contains execution result with errors
+ */
+function extractExecutionResult(output) {
+    if (!output || typeof output !== 'object')
+        return null;
+    const obj = output;
+    // Check if it looks like an ExecutionResult
+    if ('execution_ok' in obj ||
+        'code_error' in obj ||
+        'execution_error' in obj ||
+        'exit_code' in obj) {
+        return obj;
+    }
+    return null;
+}
 /**
  * Get status info (label, color, icon) for tool state
  */
-function getStatusInfo(state) {
+function getStatusInfo(state, executionResult) {
+    // Check for execution errors in the result
+    if (executionResult) {
+        if (!executionResult.execution_ok) {
+            return { label: 'Execution Failed', color: 'danger.fg', icon: '⚠' };
+        }
+        if (executionResult.code_error) {
+            return { label: 'Code Error', color: 'severe.fg', icon: '✕' };
+        }
+        // Check for non-zero exit code
+        if (executionResult.exit_code != null && executionResult.exit_code !== 0) {
+            return {
+                label: `Exit ${executionResult.exit_code}`,
+                color: 'attention.fg',
+                icon: '⚠',
+            };
+        }
+    }
     const statusMap = {
         call: { label: 'Pending', color: 'accent.fg', icon: '○' },
         'input-streaming': { label: 'Pending', color: 'accent.fg', icon: '○' },
@@ -48,12 +81,23 @@ function getStatusInfo(state) {
  * - Status indicator (pending, running, completed, error)
  * - JSON display for input parameters
  * - JSON display for output/result
- * - Error highlighting
+ * - Rich error display with execution vs code error distinction
  */
 export function ToolPart({ part }) {
     const [isExpanded, setIsExpanded] = React.useState(true);
-    const statusInfo = getStatusInfo(part.state);
+    // Extract execution result if present in output
+    const executionResult = extractExecutionResult(part.output);
+    const statusInfo = getStatusInfo(part.state, executionResult);
     const toolName = part.type.split('-').slice(1).join('-') || part.type;
+    const effectiveExitOutput = executionResult?.output ??
+        (typeof part.output === 'string'
+            ? part.output
+            : part.output != null && typeof part.output === 'object'
+                ? (part.output.output ??
+                    part.output.stdout ??
+                    part.output.stderr ??
+                    undefined)
+                : undefined);
     return (_jsxs(Box, { sx: {
             marginBottom: 2,
             border: '1px solid',
@@ -141,9 +185,101 @@ export function ToolPart({ part }) {
                                         ? typeof part.output === 'string'
                                             ? part.output
                                             : JSON.stringify(part.output, null, 2)
-                                        : 'No output' }) })] })), part.state === 'output-error' &&
+                                        : 'No output' }) })] })), executionResult && !executionResult.execution_ok && (_jsxs(Box, { sx: { padding: 3 }, children: [_jsxs(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'danger.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    marginBottom: 2,
+                                }, children: [_jsx(AlertIcon, { size: 12 }), " Execution Error"] }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'danger.subtle',
+                                    borderRadius: 2,
+                                    overflow: 'auto',
+                                    border: '1px solid',
+                                    borderColor: 'danger.muted',
+                                    padding: 2,
+                                }, children: [_jsx(Text, { sx: { fontSize: 0, color: 'danger.fg' }, children: executionResult.execution_error ||
+                                            'Sandbox execution failed' }), _jsx(Text, { sx: {
+                                            display: 'block',
+                                            fontSize: 0,
+                                            color: 'fg.muted',
+                                            marginTop: 1,
+                                        }, children: "The sandbox or execution environment failed to run the code." })] })] })), executionResult &&
+                        executionResult.execution_ok &&
+                        executionResult.code_error && (_jsxs(Box, { sx: { padding: 3 }, children: [_jsxs(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'severe.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    marginBottom: 2,
+                                }, children: ["Code Error: ", executionResult.code_error.name] }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'severe.subtle',
+                                    borderRadius: 2,
+                                    overflow: 'hidden',
+                                    border: '1px solid',
+                                    borderColor: 'severe.muted',
+                                }, children: [_jsx(Box, { sx: { padding: 2 }, children: _jsx(Text, { sx: { fontSize: 0, color: 'severe.fg' }, children: executionResult.code_error.value }) }), executionResult.code_error.traceback && (_jsx(Box, { sx: {
+                                            borderTop: '1px solid',
+                                            borderColor: 'severe.muted',
+                                            backgroundColor: 'canvas.inset',
+                                        }, children: _jsx("pre", { style: {
+                                                margin: 0,
+                                                padding: '8px 12px',
+                                                fontSize: '11px',
+                                                fontFamily: 'monospace',
+                                                lineHeight: 1.4,
+                                                whiteSpace: 'pre-wrap',
+                                                wordBreak: 'break-word',
+                                                maxHeight: '200px',
+                                                overflow: 'auto',
+                                            }, children: executionResult.code_error.traceback }) }))] })] })), executionResult &&
+                        executionResult.execution_ok &&
+                        !executionResult.code_error &&
+                        executionResult.exit_code != null &&
+                        executionResult.exit_code !== 0 && (_jsxs(Box, { sx: { padding: 3 }, children: [_jsx(Text, { sx: {
+                                    display: 'block',
+                                    fontSize: 0,
+                                    fontWeight: 'semibold',
+                                    color: 'attention.fg',
+                                    textTransform: 'uppercase',
+                                    letterSpacing: '0.05em',
+                                    marginBottom: 2,
+                                }, children: "Process Exited" }), _jsxs(Box, { sx: {
+                                    backgroundColor: 'attention.subtle',
+                                    borderRadius: 2,
+                                    overflow: 'hidden',
+                                    border: '1px solid',
+                                    borderColor: 'attention.muted',
+                                    padding: 2,
+                                }, children: [_jsxs(Text, { sx: { fontSize: 0, color: 'attention.fg' }, children: ["Process exited with code ", executionResult.exit_code] }), _jsx(Text, { sx: {
+                                            display: 'block',
+                                            fontSize: 0,
+                                            color: 'fg.muted',
+                                            marginTop: 1,
+                                        }, children: "The code called sys.exit() with a non-zero exit code." }), effectiveExitOutput && (_jsx(Box, { sx: {
+                                            mt: 2,
+                                            backgroundColor: 'canvas.inset',
+                                            borderRadius: 2,
+                                            border: '1px solid',
+                                            borderColor: 'attention.muted',
+                                            overflow: 'auto',
+                                        }, children: _jsx("pre", { style: {
+                                                margin: 0,
+                                                padding: '10px 12px',
+                                                fontSize: '12px',
+                                                fontFamily: 'monospace',
+                                                lineHeight: 1.4,
+                                                whiteSpace: 'pre-wrap',
+                                                wordBreak: 'break-word',
+                                                maxHeight: '200px',
+                                            }, children: effectiveExitOutput }) }))] })] })), part.state === 'output-error' &&
                         'errorText' in part &&
-                        part.errorText && (_jsxs(Box, { sx: { padding: 3 }, children: [_jsx(Text, { sx: {
+                        part.errorText &&
+                        !executionResult && (_jsxs(Box, { sx: { padding: 3 }, children: [_jsx(Text, { sx: {
                                     display: 'block',
                                     fontSize: 0,
                                     fontWeight: 'semibold',

package/lib/components/chat/index.d.ts

@@ -56,6 +56,6 @@ export { BaseProtocolAdapter, AGUIAdapter, A2AAdapter, ACPAdapter, type AGUIAdap
 export { ToolExecutor, type ToolExecutionContext } from './tools';
 export { MiddlewarePipeline, createMiddleware, loggingMiddleware, createHITLMiddleware, type RequestContext, type ResponseContext, } from './middleware';
 export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, createA2UIRenderer, A2UIExtensionImpl, type A2UIMessage, } from './extensions';
-export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, type ChatMessagesProps, type ChatInputPromptProps, type ChatSidebarProps, type ChatStandaloneProps, type MessageHandler, type ChatBaseProps, type ProtocolConfig, type ToolApprovalDialogProps, type PoweredByTagProps, type FloatingBrandButtonProps, type ChatFloatingProps, type ToolCallRenderContext, type ToolCallStatus, type RenderToolResult, type RespondCallback, type Suggestion, type RemoteConfig, type ModelConfig, type BuiltinTool, type MCPServerConfig, type MCPServerTool, type ChatHeaderProps, type ConnectionState, type MessagePartProps, type TextPartProps, type ReasoningPartProps, type ToolPartProps, type DynamicToolPartProps, type ToolCallDisplayProps, type ChatProps, type Transport, type Extension, } from './components';
+export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, AgentDetails, AgentIdentity, IdentityCard, getTokenStatus, formatDuration, formatExpirationStatus, type ChatMessagesProps, type ChatInputPromptProps, type ChatSidebarProps, type ChatStandaloneProps, type MessageHandler, type ChatBaseProps, type ProtocolConfig, type ToolApprovalDialogProps, type PoweredByTagProps, type FloatingBrandButtonProps, type ChatFloatingProps, type ToolCallRenderContext, type ToolCallStatus, type RenderToolResult, type RespondCallback, type Suggestion, type RemoteConfig, type ModelConfig, type BuiltinTool, type MCPServerConfig, type MCPServerTool, type AgentDetailsProps, type AgentIdentityProps, type IdentityCardProps, type TokenStatus, type ChatHeaderProps, type ConnectionState, type MessagePartProps, type TextPartProps, type ReasoningPartProps, type ToolPartProps, type DynamicToolPartProps, type ToolCallDisplayProps, type ChatProps, type Transport, type Extension, } from './components';
 export { requestAPI } from './handler';
 export { useKeyboardShortcuts, useChatKeyboardShortcuts, getShortcutDisplay, type KeyboardShortcut, type UseKeyboardShortcutsOptions, } from '../../hooks';

package/lib/components/chat/index.js

@@ -69,7 +69,7 @@ export { MiddlewarePipeline, createMiddleware, loggingMiddleware, createHITLMidd
 // Extensions
 export { ExtensionRegistry, createMessageRenderer, createActivityRenderer, createA2UIRenderer, A2UIExtensionImpl, } from './extensions';
 // Components
-export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, } from './components';
+export { ChatMessages, ChatInputPrompt, ChatSidebar, ChatStandalone, ChatBase, ToolApprovalDialog, useToolApprovalDialog, PoweredByTag, FloatingBrandButton, ChatHeader, MessagePart, TextPart, ReasoningPart, ToolPart, DynamicToolPart, ToolCallDisplay, Chat, ChatFloating, AgentDetails, AgentIdentity, IdentityCard, getTokenStatus, formatDuration, formatExpirationStatus, } from './components';
 // Simple API request handler (merged from chat)
 export { requestAPI } from './handler';
 // Keyboard shortcuts (re-exported from main hooks folder)

package/lib/components/chat/protocols/A2AAdapter.d.ts

@@ -53,6 +53,15 @@ export declare class A2AAdapter extends BaseProtocolAdapter {
         metadata?: Record<string, unknown>;
         /** Model to use for this request (overrides agent default) */
         model?: string;
+        /** Built-in MCP tool names to enable */
+        builtinTools?: string[];
+        /** Skill IDs to enable */
+        skills?: string[];
+        /** Connected identity tokens to pass to backend for tool execution */
+        identities?: Array<{
+            provider: string;
+            accessToken: string;
+        }>;
     }): Promise<void>;
     /**
      * Send tool result back

package/lib/components/chat/protocols/A2AAdapter.js

@@ -121,6 +121,14 @@ export class A2AAdapter extends BaseProtocolAdapter {
                 }
             }
         }
+        // Build metadata with model and identities
+        const metadata = {};
+        if (options?.model) {
+            metadata.model = options.model;
+        }
+        if (options?.identities && options.identities.length > 0) {
+            metadata.identities = options.identities;
+        }
         // Build JSON-RPC request with A2A message format
         // Use message/stream for SSE streaming responses
         const messageId = generateMessageId();
@@ -142,14 +150,17 @@ export class A2AAdapter extends BaseProtocolAdapter {
                     // The model is configured at agent creation time
                     ...(options?.model && { model: options.model }),
                 },
-                // Also send model in metadata for potential future support
-                ...(options?.model && { metadata: { model: options.model } }),
+                // Also send metadata with model and identities
+                ...(Object.keys(metadata).length > 0 && { metadata }),
             },
             id: taskId,
         };
         if (options?.model) {
             console.log('[A2AAdapter] Sending with model:', options.model, '(Note: A2A uses agent-level model, not per-request)');
         }
+        if (options?.identities && options.identities.length > 0) {
+            console.log('[A2AAdapter] Sending with identities:', options.identities.map(i => i.provider));
+        }
         try {
             const response = await fetch(this.a2aConfig.baseUrl, {
                 method: 'POST',

package/lib/components/chat/protocols/ACPAdapter.d.ts

@@ -115,6 +115,15 @@ export declare class ACPAdapter extends BaseProtocolAdapter {
         metadata?: Record<string, unknown>;
         /** Model to use for this request (overrides agent default) */
         model?: string;
+        /** Built-in MCP tool names to enable */
+        builtinTools?: string[];
+        /** Skill IDs to enable */
+        skills?: string[];
+        /** Connected identity tokens to pass to backend for tool execution */
+        identities?: Array<{
+            provider: string;
+            accessToken: string;
+        }>;
     }): Promise<void>;
     /**
      * Send tool result back through ACP

package/lib/components/chat/protocols/ACPAdapter.js

@@ -224,11 +224,22 @@ export class ACPAdapter extends BaseProtocolAdapter {
             if (_options?.model) {
                 console.log('[ACPAdapter] Sending with model:', _options.model);
             }
+            if (_options?.identities && _options.identities.length > 0) {
+                console.log('[ACPAdapter] Sending with identities:', _options.identities.map(i => i.provider));
+            }
+            // Build metadata including model override and identities
+            const metadata = {};
+            if (_options?.model) {
+                metadata.model = _options.model;
+            }
+            if (_options?.identities && _options.identities.length > 0) {
+                metadata.identities = _options.identities;
+            }
             await this.sendRequest(AGENT_METHODS.session_prompt, {
                 sessionId: this.session.sessionId,
                 content: [{ type: 'text', text: content }],
-                // Include model for per-request model override
-                ...(_options?.model && { metadata: { model: _options.model } }),
+                // Include metadata with model and identities
+                ...(Object.keys(metadata).length > 0 && { metadata }),
             });
         }
         catch (error) {

package/lib/components/chat/protocols/AGUIAdapter.d.ts

@@ -54,6 +54,15 @@ export declare class AGUIAdapter extends BaseProtocolAdapter {
         messages?: ChatMessage[];
         /** Model to use for this request (overrides agent default) */
         model?: string;
+        /** Built-in MCP tool names to enable */
+        builtinTools?: string[];
+        /** Skill IDs to enable */
+        skills?: string[];
+        /** Connected identity tokens to pass to backend for tool execution */
+        identities?: Array<{
+            provider: string;
+            accessToken: string;
+        }>;
     }): Promise<void>;
     /**
      * Send tool result back through AG-UI and continue the conversation