@datalayer/agent-runtimes 1.0.3 → 1.0.4

package/lib/examples/ChatExample.js

@@ -17,9 +17,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  */
 import { useEffect, useState } from 'react';
 import { Text, Spinner } from '@primer/react';
-import { AlertIcon } from '@primer/octicons-react';
 import { Box, setupPrimerPortals } from '@datalayer/primer-addons';
 import { ThemedProvider } from './utils/themedProvider';
+import { ErrorView } from './components';
 import { Chat } from '../chat';
 setupPrimerPortals();
 const BASE_URL = 'http://localhost:8765';
@@ -101,15 +101,7 @@ const AgentRuntimeChatExample = () => {
     }
     // Error state
     if (error || !agentId) {
-        return (_jsx(ThemedProvider, { children: _jsxs(Box, { sx: {
-                    display: 'flex',
-                    flexDirection: 'column',
-                    alignItems: 'center',
-                    justifyContent: 'center',
-                    height: '100vh',
-                    gap: 3,
-                    bg: 'canvas.default',
-                }, children: [_jsx(AlertIcon, { size: 48 }), _jsx(Text, { sx: { color: 'danger.fg', fontSize: 2 }, children: "Failed to start agent" }), _jsx(Text, { sx: { color: 'fg.muted', fontSize: 1 }, children: error || 'No agent ID returned' })] }) }));
+        return (_jsx(ThemedProvider, { children: _jsx(ErrorView, { error: "Failed to start agent", detail: error || 'No agent ID returned' }) }));
     }
     // Agent is ready — render the Chat component
     return (_jsx(Chat, { protocol: "ag-ui", baseUrl: BASE_URL, agentId: agentId, title: "Simple Agent", placeholder: "Send a message...", description: "Chat with a simple AI assistant", showHeader: true, showModelSelector: true, showToolsMenu: true, showSkillsMenu: true, showTokenUsage: true, showInformation: true, autoFocus: true, height: "100vh", runtimeId: agentId, historyEndpoint: `${BASE_URL}/api/v1/history`, suggestions: [

package/lib/examples/components/ErrorView.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type ErrorViewProps = {
+    /** Primary error message. Falls back to "Agent failed to start". */
+    error?: string | null;
+    /** Optional secondary detail line shown below the primary message. */
+    detail?: string | null;
+    /** Called when the user clicks "Sign out". Button only appears for 401 errors. */
+    onLogout?: () => void;
+};
+/**
+ * Full-screen error view used by examples when agent creation fails.
+ * Automatically shows a "Sign out" button when the error contains "401".
+ */
+export declare const ErrorView: React.FC<ErrorViewProps>;

package/lib/examples/components/ErrorView.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Button } from '@primer/react';
+import { AlertIcon, SignOutIcon } from '@primer/octicons-react';
+import { Box } from '@datalayer/primer-addons';
+/**
+ * Full-screen error view used by examples when agent creation fails.
+ * Automatically shows a "Sign out" button when the error contains "401".
+ */
+export const ErrorView = ({ error, detail, onLogout, }) => {
+    const message = error || 'Agent failed to start';
+    const is401 = String(message).includes('401') || String(detail || '').includes('401');
+    return (_jsxs(Box, { sx: {
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            height: '100vh',
+            gap: 3,
+        }, children: [_jsx(AlertIcon, { size: 48 }), _jsx(Text, { sx: { color: 'danger.fg', fontSize: 2 }, children: message }), detail && _jsx(Text, { sx: { color: 'fg.muted' }, children: detail }), is401 && onLogout && (_jsx(Button, { variant: "danger", leadingVisual: SignOutIcon, onClick: onLogout, children: "Sign out" }))] }));
+};

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

@@ -1,3 +1,5 @@
+export { ErrorView } from './ErrorView';
+export type { ErrorViewProps } from './ErrorView';
 export { MockFileBrowser } from './MockFileBrowser';
 export type { MockFileBrowserProps } from './MockFileBrowser';
 export { MainContent } from './MainContent';

package/lib/examples/components/index.js

@@ -3,6 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 // Example/layout components
+export { ErrorView } from './ErrorView';
 export { MockFileBrowser } from './MockFileBrowser';
 export { MainContent } from './MainContent';
 export { SessionTabs } from './SessionTabs';

package/lib/examples/main.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { createRoot } from 'react-dom/client';
+import '../../style/primer-primitives.css';
 declare global {
     interface Window {
         __agentRuntimesExamplesRoot?: ReturnType<typeof createRoot>;

package/lib/examples/main.js

@@ -17,6 +17,7 @@ import { EXAMPLES } from './example-selector';
 import { useExampleThemeStore } from './utils/themeStore';
 import { ExampleWrapper } from './components/ExampleWrapper';
 import nbformatExample from './utils/notebooks/NotebookExample1.ipynb.json';
+import '../../style/primer-primitives.css';
 // Load configurations from DOM
 const loadConfigurations = () => {
     // Load Datalayer configuration

package/lib/protocols/VercelAIAdapter.d.ts

@@ -42,7 +42,9 @@ export declare class VercelAIAdapter extends BaseProtocolAdapter {
     private messageHistory;
     private lastAssistantText;
     private lastTools;
+    private lastFrontendToolNames;
     private isContinuation;
+    private deferredToolMeta;
     private _streamParsingDepth;
     private _streamDonePromise;
     private _streamDoneResolve;

package/lib/protocols/VercelAIAdapter.js

@@ -22,7 +22,13 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
     messageHistory = [];
     lastAssistantText = '';
     lastTools = [];
+    lastFrontendToolNames = new Set();
     isContinuation = false;
+    // Metadata for ALL deferred tool calls (frontend + approval), keyed by toolCallId.
+    // Unlike pendingToolCalls (which only tracks frontend tools for batching),
+    // this preserves tool name/args for approval tools so sendToolResult can
+    // build a correct continuation message.
+    deferredToolMeta = new Map();
     // Stream parsing depth — prevents premature continuations
     _streamParsingDepth = 0;
     _streamDonePromise = null;
@@ -97,10 +103,17 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
         // Store tools for potential continuation
         if (options?.tools) {
             this.lastTools = options.tools;
+            this.lastFrontendToolNames = new Set(options.tools
+                .map(t => t?.name)
+                .filter((name) => Boolean(name)));
+        }
+        else {
+            this.lastFrontendToolNames = new Set();
         }
         // Reset assistant content tracking for fresh (non-continuation) messages
         if (!this.isContinuation) {
             this.lastAssistantText = '';
+            this.deferredToolMeta.clear();
         }
         try {
             let vercelMessages;
@@ -156,6 +169,9 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
             const requestBody = {
                 id: requestId,
                 messages: vercelMessages,
+                // Required for pydantic-ai deferred tool approval continuations.
+                // sdkVersion 6 enables parsing approval-responded tool parts.
+                sdkVersion: 6,
                 trigger: 'submit-message',
                 ...(options?.tools && { tools: options.tools }),
                 ...(options?.model && { model: options.model }),
@@ -439,12 +455,9 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                     event.tool?.name;
                                 const args = normalizeToolArgs(event.input || event.args || event.arguments, pending?.inputText || '');
                                 if (toolName) {
-                                    // Track as a pending frontend tool call for continuation
-                                    this.pendingToolCalls.set(toolCallId, {
-                                        toolCallId,
-                                        toolName,
-                                        args,
-                                    });
+                                    // Emit tool-call for all tools so UI can render a tool entry.
+                                    // Only client-declared frontend tools should participate in
+                                    // frontend continuation batching via pendingToolCalls.
                                     this.emit({
                                         type: 'tool-call',
                                         toolCall: {
@@ -454,6 +467,20 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                         },
                                         timestamp: new Date(),
                                     });
+                                    // Track metadata for ALL deferred tools so sendToolResult
+                                    // can build proper continuation messages (tool name + args).
+                                    this.deferredToolMeta.set(toolCallId, {
+                                        toolCallId,
+                                        toolName,
+                                        args,
+                                    });
+                                    if (this.lastFrontendToolNames.has(toolName)) {
+                                        this.pendingToolCalls.set(toolCallId, {
+                                            toolCallId,
+                                            toolName,
+                                            args,
+                                        });
+                                    }
                                 }
                             }
                             else if (event.type === 'tool-output-available') {
@@ -475,6 +502,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                 // Server already executed this tool — remove from pending
                                 // frontend tool calls so emitDoneOnce is not blocked.
                                 this.pendingToolCalls.delete(toolCallId);
+                                this.deferredToolMeta.delete(toolCallId);
                             }
                             else if (event.type === 'tool-output-error' ||
                                 event.type === 'tool-error') {
@@ -489,6 +517,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                 // Server handled the error — clear from pending frontend
                                 // tool calls so emitDoneOnce is not blocked.
                                 this.pendingToolCalls.delete(toolCallId);
+                                this.deferredToolMeta.delete(toolCallId);
                                 this.emit({
                                     type: 'tool-result',
                                     toolResult: {
@@ -575,8 +604,10 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
             toolResult: result,
             timestamp: new Date(),
         });
-        // 2. Retrieve tool metadata from pending map
-        const pendingToolCall = this.pendingToolCalls.get(toolCallId);
+        // 2. Retrieve tool metadata from pending map (frontend tools) or
+        //    deferred tool meta (approval / all deferred tools).
+        const pendingToolCall = this.pendingToolCalls.get(toolCallId) ??
+            this.deferredToolMeta.get(toolCallId);
         if (!pendingToolCall) {
             console.warn('[VercelAIAdapter] No pending tool call found for ID:', toolCallId);
         }
@@ -613,18 +644,53 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                 state: 'done',
             });
         }
-        // Add each tool call with its result as a DynamicToolUIPart
+        // Add each tool call with its result as a dynamic-tool part.
+        // pydantic-ai parses DynamicTool* parts with output-available / output-error
+        // and approval-responded states for deferred approval continuations.
         for (const tr of this.collectedToolResults.values()) {
-            assistantParts.push({
-                type: 'dynamic-tool',
-                toolName: tr.toolName,
-                toolCallId: tr.toolCallId,
-                state: 'output-available',
-                input: tr.args,
-                output: tr.result.success
-                    ? tr.result.result
-                    : { error: tr.result.error ?? 'Tool execution failed' },
-            });
+            const resultObj = tr.result.result && typeof tr.result.result === 'object'
+                ? tr.result.result
+                : undefined;
+            const isApprovalDecision = !!resultObj && typeof resultObj.approved === 'boolean';
+            if (isApprovalDecision) {
+                const approvalId = typeof resultObj?.approvalId === 'string'
+                    ? resultObj.approvalId
+                    : tr.toolCallId;
+                const approved = Boolean(resultObj?.approved);
+                const reason = typeof resultObj?.message === 'string' ? resultObj.message : undefined;
+                assistantParts.push({
+                    type: 'dynamic-tool',
+                    toolName: tr.toolName,
+                    toolCallId: tr.toolCallId,
+                    state: 'approval-responded',
+                    input: tr.args,
+                    approval: {
+                        id: approvalId,
+                        approved,
+                        ...(reason ? { reason } : {}),
+                    },
+                });
+            }
+            else if (tr.result.success) {
+                assistantParts.push({
+                    type: 'dynamic-tool',
+                    toolName: tr.toolName,
+                    toolCallId: tr.toolCallId,
+                    state: 'output-available',
+                    input: tr.args,
+                    output: tr.result.result,
+                });
+            }
+            else {
+                assistantParts.push({
+                    type: 'dynamic-tool',
+                    toolName: tr.toolName,
+                    toolCallId: tr.toolCallId,
+                    state: 'output-error',
+                    input: tr.args,
+                    errorText: tr.result.error ?? 'Tool execution failed',
+                });
+            }
         }
         const assistantMessage = {
             id: generateMessageId(),
@@ -636,9 +702,9 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
         // 7. Clear batching state BEFORE the async sendMessage call
         this.pendingToolCalls.clear();
         this.collectedToolResults.clear();
+        this.deferredToolMeta.clear();
         // 8. Update stored message history
         this.messageHistory = continuationMessages;
-        console.log('[VercelAIAdapter] === CONTINUATION MESSAGES ===', continuationMessages.map((m, i) => `[${i}] role=${m.role} parts=${m.parts.length}`));
         // 9. Mark as continuation
         this.isContinuation = true;
         // 10. Send ONE continuation request with all tool results

package/lib/shims/json5.d.ts

@@ -0,0 +1,4 @@
+import JSON5 from 'json5/dist/index.mjs';
+export declare const parse: any;
+export declare const stringify: any;
+export default JSON5;

package/lib/shims/json5.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import JSON5 from 'json5/dist/index.mjs';
+export const parse = JSON5.parse.bind(JSON5);
+export const stringify = JSON5.stringify.bind(JSON5);
+export default JSON5;