@datalayer/agent-runtimes 1.0.3 → 1.0.5

package/lib/index.d.ts

@@ -1,8 +1,9 @@
 export * from './chat';
+export * from './client';
 export * from './components';
 export * from './mcp';
 export * from './stores';
 export * from './identity';
 export * from './config';
 export * from './specs';
-export type { AgentRuntimeData, AgentSpec, TeamSpec, GuardrailSpec, EvalSpec, TriggerSpec, OutputSpec, NotificationChannelSpec, MCPServer, SkillSpec, EnvvarSpec, } from './types';
+export type { AgentRuntimeData, AgentSpec, ChatCommonProps, TeamSpec, GuardrailSpec, EvalSpec, TriggerSpec, OutputSpec, NotificationChannelSpec, MCPServer, SkillSpec, SkillInfo, SkillStatus, EnvvarSpec, ToolCallStartContext, ToolCallCompleteContext, } from './types';

package/lib/index.js

@@ -3,6 +3,7 @@
  * Distributed under the terms of the Modified BSD License.
  */
 export * from './chat';
+export * from './client';
 export * from './components';
 export * from './mcp';
 export * from './stores';

package/lib/inference/index.d.ts

@@ -6,4 +6,3 @@
 export { BaseInferenceProvider } from './BaseInferenceProvider';
 export { DatalayerInferenceProvider, type DatalayerInferenceConfig, } from './DatalayerInferenceProvider';
 export { SelfHostedInferenceProvider, type SelfHostedInferenceConfig, } from './SelfHostedInferenceProvider';
-export type { InferenceProvider, InferenceProviderConfig, InferenceProviderFactory, InferenceProviderType, InferenceRequestOptions, InferenceResponse, StreamEvent, StreamEventType, StreamEventHandler, } from '../types/inference';

package/lib/middleware/index.d.ts

@@ -4,4 +4,3 @@
  * @module middleware
  */
 export { MiddlewarePipeline, createMiddleware, loggingMiddleware, createHITLMiddleware, type RequestContext, type ResponseContext, } from './MiddlewarePipeline';
-export type { ChatMiddleware, MiddlewareContext } from '../types/middleware';

package/lib/protocols/AGUIAdapter.js

@@ -168,6 +168,12 @@ export class AGUIAdapter extends BaseProtocolAdapter {
             messages: aguiMessages,
             state: null,
             tools: options?.tools || [],
+            ...(options?.builtinTools !== undefined && {
+                builtinTools: options.builtinTools,
+            }),
+            ...(options?.skills !== undefined && {
+                skills: options.skills,
+            }),
             context: [],
             forwardedProps: null,
             // Include model for per-request model override

package/lib/protocols/VercelAIAdapter.d.ts

@@ -42,10 +42,19 @@ export declare class VercelAIAdapter extends BaseProtocolAdapter {
     private messageHistory;
     private lastAssistantText;
     private lastTools;
+    private lastFrontendToolNames;
     private isContinuation;
+    private deferredToolMeta;
     private _streamParsingDepth;
     private _streamDonePromise;
     private _streamDoneResolve;
+    /**
+     * Return the toolCallId for the first deferred tool whose name matches
+     * toolName, or the first deferred tool if toolName is empty/unmatched.
+     * Used by external callers (e.g. approval handlers) that need to send a
+     * continuation without access to the original tool-call-id.
+     */
+    getDeferredToolCallId(toolName: string): string | undefined;
     constructor(config: VercelAIAdapterConfig);
     /**
      * Connect to Vercel AI endpoint (SSE doesn't require persistent connection)

package/lib/protocols/VercelAIAdapter.js

@@ -22,11 +22,37 @@ 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;
     _streamDoneResolve = null;
+    /**
+     * Return the toolCallId for the first deferred tool whose name matches
+     * toolName, or the first deferred tool if toolName is empty/unmatched.
+     * Used by external callers (e.g. approval handlers) that need to send a
+     * continuation without access to the original tool-call-id.
+     */
+    getDeferredToolCallId(toolName) {
+        if (!toolName) {
+            return this.deferredToolMeta.keys().next().value;
+        }
+        for (const [id, meta] of this.deferredToolMeta) {
+            if (meta.toolName === toolName ||
+                meta.toolName === toolName.replace(/-/g, '_') ||
+                meta.toolName === toolName.replace(/_/g, '-')) {
+                return id;
+            }
+        }
+        // Fall back to first entry if name didn't match (handles name normalisation edge cases)
+        return this.deferredToolMeta.keys().next().value;
+    }
     constructor(config) {
         super(config);
         this.vercelConfig = config;
@@ -97,10 +123,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,15 +189,16 @@ 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 }),
-                ...(options?.builtinTools &&
-                    options.builtinTools.length > 0 && {
+                ...(options?.builtinTools !== undefined && {
                     builtinTools: options.builtinTools,
                 }),
-                ...(options?.skills &&
-                    options.skills.length > 0 && {
+                ...(options?.skills !== undefined && {
                     skills: options.skills,
                 }),
                 ...(options?.identities &&
@@ -237,6 +271,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
         let currentMessageId = generateMessageId();
         let accumulatedText = '';
         const pendingToolInputs = new Map();
+        const pendingApprovalIds = new Map();
         let doneEmitted = false;
         // Consume the continuation flag — set by sendToolResult for this call only
         this.isContinuation = false;
@@ -383,6 +418,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                     // not frontend tools that will be handled by sendToolResult)
                                     for (const [toolCallId] of pendingToolInputs.entries()) {
                                         if (!this.pendingToolCalls.has(toolCallId)) {
+                                            const approvalId = pendingApprovalIds.get(toolCallId);
                                             this.emit({
                                                 type: 'tool-result',
                                                 toolResult: {
@@ -390,6 +426,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                                     success: true,
                                                     result: {
                                                         pending_approval: true,
+                                                        approval_id: approvalId,
                                                         message: 'Awaiting user approval',
                                                     },
                                                 },
@@ -439,12 +476,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 +488,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') {
@@ -472,9 +520,11 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                     timestamp: new Date(),
                                 });
                                 pendingToolInputs.delete(toolCallId);
+                                pendingApprovalIds.delete(toolCallId);
                                 // 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 +539,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: {
@@ -500,6 +551,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                     timestamp: new Date(),
                                 });
                                 pendingToolInputs.delete(toolCallId);
+                                pendingApprovalIds.delete(toolCallId);
                             }
                             else if (event.type === 'error') {
                                 const errorMessage = event.error ||
@@ -514,9 +566,18 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                     timestamp: new Date(),
                                 });
                             }
+                            else if (event.type === 'tool-approval-request') {
+                                const toolCallId = event.toolCallId ||
+                                    event.tool_call_id ||
+                                    event.id ||
+                                    generateMessageId();
+                                const approvalId = event.approvalId || event.approval_id;
+                                if (typeof approvalId === 'string' && approvalId.length > 0) {
+                                    pendingApprovalIds.set(toolCallId, approvalId);
+                                }
+                            }
                             else if (event.type === 'tool-call' ||
-                                event.type === 'tool-call-start' ||
-                                event.type === 'tool-approval-request') {
+                                event.type === 'tool-call-start') {
                                 const toolName = event.toolName ||
                                     event.tool_name ||
                                     event.name ||
@@ -569,14 +630,26 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
      * ONE continuation request once ALL pending tool calls have been resolved.
      */
     async sendToolResult(toolCallId, result) {
+        console.info('[VercelAIAdapter] sendToolResult called', {
+            toolCallId,
+            success: result?.success,
+            hasApprovalDecision: !!result?.result &&
+                typeof result.result === 'object' &&
+                typeof result.result.approved ===
+                    'boolean',
+            knownDeferredToolCallIds: Array.from(this.deferredToolMeta.keys()),
+            pendingToolCallIds: Array.from(this.pendingToolCalls.keys()),
+        });
         // 1. Emit local event for UI updates
         this.emit({
             type: 'tool-result',
             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 +686,55 @@ 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 +746,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
@@ -648,6 +758,14 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
             content: '',
             createdAt: new Date(),
         };
+        console.info('[VercelAIAdapter] Sending continuation request', {
+            messageCount: continuationMessages.length,
+            assistantParts: assistantParts.map(p => ({
+                type: p.type,
+                state: p.state,
+                toolName: p.toolName,
+            })),
+        });
         await this.sendMessage(dummyMessage, {
             _vercelMessages: continuationMessages,
             tools: this.lastTools,

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;

package/lib/specs/agents/agents.d.ts

@@ -14,10 +14,20 @@ export declare const CLASSIFY_ROUTE_EMAILS_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const COMPREHENSIVE_SALES_ANALYTICS_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const CRAWLER_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const DATA_ACQUISITION_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DATALAYER_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const DEMO_FULL_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_GUARDRAILS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_HOOKS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_MCP_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_MONITORING_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const DEMO_ONE_TRIGGER_APPROVAL_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const DEMO_ONE_TRIGGER_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_OUTPUTS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_PARAMETERS_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const DEMO_SIMPLE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_SUBAGENTS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_TAVILY_CODEMODE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_TAVILY_NO_CODEMODE_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const END_OF_MONTH_SALES_PERFORMANCE_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const EXTRACT_DATA_FROM_FILES_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const FINANCIAL_VIZ_AGENT_SPEC_0_0_1: AgentSpec;