@datalayer/agent-runtimes 1.0.4 → 1.0.6

package/lib/hooks/useToolApprovals.js

@@ -3,99 +3,348 @@
  * Distributed under the terms of the Modified BSD License.
  */
 /**
- * Agent tool approval hooks.
+ * Agent tool approval hooks (WebSocket-only).
+ *
+ * All tool-approval interactions flow over the AI Agents websocket stream.
+ * There are no REST endpoints — the server publishes approval snapshots and
+ * `tool_approval_*` events, and the client sends `tool_approval_decision`
+ * messages to approve/reject pending requests.
+ *
+ * Consumers use the familiar React Query-style API below. Internally the
+ * hooks:
+ *   - subscribe to the shared AI Agents WS once per component tree
+ *   - seed/update the `['tool-approvals', filters]` query cache from events
+ *   - send decision messages over the same socket for mutations
  *
  * @module hooks/useToolApprovals
  */
-import { useMemo } from 'react';
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { useCoreStore, useIAMStore } from '@datalayer/core/lib/state';
-import { DEFAULT_SERVICE_URLS } from '@datalayer/core/lib/api/constants';
-import { toolApprovals } from '../api';
-// ─── Auth helpers ────────────────────────────────────────────────────
-function useDashboardAuthToken() {
-    const token = useIAMStore((s) => s.token);
-    return token ?? '';
-}
-function useDashboardBaseUrl() {
-    const config = useCoreStore((s) => s.configuration);
-    return config?.aiagentsRunUrl ?? DEFAULT_SERVICE_URLS.AI_AGENTS;
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { useAIAgentsWebSocket } from './useAIAgentsWebSocket';
+// ─── Helpers ─────────────────────────────────────────────────────────
+const APPROVALS_ROOT_KEY = ['tool-approvals'];
+function str(value) {
+    return typeof value === 'string' ? value : value == null ? '' : String(value);
+}
+function normalizeApproval(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const rec = raw;
+    const id = typeof rec.id === 'string' ? rec.id : undefined;
+    if (!id)
+        return null;
+    const agent = str(rec.agent_id ?? rec.agentId);
+    const pod = str(rec.pod_name ?? rec.podName);
+    const tool = str(rec.tool_name ?? rec.toolName ?? 'unknown');
+    const toolCall = rec.tool_call_id ?? rec.toolCallId;
+    const args = rec.tool_args ??
+        rec.toolArgs ??
+        {};
+    const created = str(rec.created_at ?? rec.createdAt);
+    const updated = str(rec.updated_at ?? rec.updatedAt);
+    return {
+        id,
+        agent_id: agent,
+        agentId: agent,
+        pod_name: pod,
+        podName: pod,
+        tool_name: tool,
+        toolName: tool,
+        tool_call_id: typeof toolCall === 'string' ? toolCall : undefined,
+        toolCallId: typeof toolCall === 'string' ? toolCall : undefined,
+        tool_args: args,
+        toolArgs: args,
+        status: str(rec.status ?? 'pending'),
+        note: typeof rec.note === 'string'
+            ? rec.note
+            : rec.note === null
+                ? null
+                : undefined,
+        created_at: created,
+        createdAt: created,
+        updated_at: updated || undefined,
+        updatedAt: updated || undefined,
+        read: typeof rec.read === 'boolean' ? rec.read : undefined,
+    };
+}
+function matchesFilter(a, filters) {
+    if (!filters)
+        return true;
+    if (filters.agentId && a.agent_id !== filters.agentId)
+        return false;
+    if (filters.status && a.status !== filters.status)
+        return false;
+    if (filters.toolName && a.tool_name !== filters.toolName)
+        return false;
+    return true;
+}
+function upsertApproval(list, approval) {
+    const idx = list.findIndex(item => item.id === approval.id);
+    if (idx === -1)
+        return [approval, ...list];
+    const copy = list.slice();
+    copy[idx] = { ...copy[idx], ...approval };
+    return copy;
+}
+function removeApproval(list, id) {
+    return list.filter(item => item.id !== id);
+}
+function writeSnapshot(queryClient, approvals) {
+    const queries = queryClient
+        .getQueryCache()
+        .findAll({ queryKey: APPROVALS_ROOT_KEY });
+    for (const q of queries) {
+        const [, second] = q.queryKey;
+        if (second === 'pending-count') {
+            queryClient.setQueryData(q.queryKey, {
+                count: approvals.filter(a => a.status === 'pending').length,
+            });
+            continue;
+        }
+        const filters = (second ?? undefined);
+        const filtered = approvals.filter(a => matchesFilter(a, filters));
+        queryClient.setQueryData(q.queryKey, {
+            approvals: filtered,
+            total: filtered.length,
+        });
+    }
+    // Ensure there's always a root cache entry so downstream consumers can
+    // compute derived values (like pending-count refetches) even when no
+    // filter query has been mounted yet.
+    queryClient.setQueryData(APPROVALS_ROOT_KEY, {
+        approvals,
+        total: approvals.length,
+    });
+}
+function patchApproval(queryClient, approval, mode) {
+    const queries = queryClient
+        .getQueryCache()
+        .findAll({ queryKey: APPROVALS_ROOT_KEY });
+    for (const q of queries) {
+        const [, second] = q.queryKey;
+        if (second === 'pending-count') {
+            // Recompute from the root cache after we finish patching below.
+            continue;
+        }
+        const filters = (second ?? undefined);
+        const current = queryClient.getQueryData(q.queryKey)?.approvals ?? [];
+        let next;
+        if (mode === 'remove') {
+            next = removeApproval(current, approval.id);
+        }
+        else {
+            next = matchesFilter(approval, filters)
+                ? upsertApproval(current, approval)
+                : removeApproval(current, approval.id);
+        }
+        queryClient.setQueryData(q.queryKey, {
+            approvals: next,
+            total: next.length,
+        });
+    }
+    // Recompute pending-count from the unfiltered root cache.
+    const root = queryClient.getQueryData(APPROVALS_ROOT_KEY)?.approvals;
+    if (root) {
+        queryClient.setQueryData(['tool-approvals', 'pending-count'], { count: root.filter(a => a.status === 'pending').length });
+    }
+}
+// ─── Shared WS bridge ─────────────────────────────────────────────────
+/**
+ * Opens a WS connection and streams snapshots + events into the React
+ * Query cache. Returns a `send` function so sibling hooks can dispatch
+ * decisions over the same socket.
+ */
+function useApprovalsSocket() {
+    const queryClient = useQueryClient();
+    const { connectionState, send } = useAIAgentsWebSocket({
+        onMessage: msg => {
+            const type = (msg.type ?? msg.event);
+            if (!type)
+                return;
+            // Response to our { type: 'tool-approvals-history' } request.
+            // Shape: { type: "tool-approvals-history", data: { approvals: [...] } }
+            if (type === 'tool-approvals-history') {
+                const data = msg.data;
+                const rawList = Array.isArray(data?.approvals) ? data.approvals : [];
+                const list = rawList
+                    .map(normalizeApproval)
+                    .filter((a) => a !== null)
+                    .filter(a => a.status !== 'deleted');
+                writeSnapshot(queryClient, list);
+                return;
+            }
+            // Incremental broadcast events from datalayer-ai-agents.
+            // Shape: { channel: "user:<uid>", event: "tool_approval_*", data: record }
+            if (type.startsWith('tool_approval_')) {
+                const rawPayload = msg.payload ??
+                    msg.data ??
+                    undefined;
+                const approval = normalizeApproval(rawPayload);
+                if (!approval)
+                    return;
+                patchApproval(queryClient, approval, type === 'tool_approval_deleted' ? 'remove' : 'upsert');
+            }
+        },
+    });
+    // Request the full approval history once connected so the sidebar badge
+    // and any pending-count consumers always show the correct count.
+    const historyAskedRef = useRef(false);
+    useEffect(() => {
+        if (connectionState !== 'connected') {
+            historyAskedRef.current = false;
+            return;
+        }
+        if (historyAskedRef.current)
+            return;
+        historyAskedRef.current = send({ type: 'tool-approvals-history' });
+    }, [connectionState, send]);
+    return { send, connectionState };
 }
 // ─── Base hooks ──────────────────────────────────────────────────────
 export function useToolApprovalsQuery(filters) {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    useApprovalsSocket();
+    const queryClient = useQueryClient();
+    const queryKey = useMemo(() => ['tool-approvals', filters], [filters]);
     return useQuery({
-        queryKey: ['tool-approvals', filters],
-        queryFn: () => toolApprovals.getToolApprovals(token, filters, baseUrl),
-        enabled: !!token,
-        staleTime: 10_000,
+        queryKey,
+        // Data is populated via the WS bridge. On invalidation, return the
+        // cached value so the fresh WS snapshot is preserved.
+        queryFn: async () => queryClient.getQueryData(queryKey) ?? {
+            approvals: [],
+            total: 0,
+        },
+        staleTime: Number.POSITIVE_INFINITY,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
     });
 }
 export function usePendingApprovalCount() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    useApprovalsSocket();
+    const queryClient = useQueryClient();
     return useQuery({
         queryKey: ['tool-approvals', 'pending-count'],
-        queryFn: () => toolApprovals.getPendingApprovalCount(token, baseUrl),
-        enabled: !!token,
-        staleTime: 5_000,
+        queryFn: async () => {
+            const cached = queryClient.getQueryData([
+                'tool-approvals',
+                'pending-count',
+            ]);
+            if (cached && typeof cached.count === 'number')
+                return cached;
+            const root = queryClient.getQueryData(APPROVALS_ROOT_KEY);
+            const pending = (root?.approvals ?? []).filter(a => a.status === 'pending').length;
+            return { count: pending };
+        },
+        staleTime: Number.POSITIVE_INFINITY,
+        refetchOnMount: false,
+        refetchOnWindowFocus: false,
+        refetchOnReconnect: false,
     });
 }
+/** Build a mutation-style object that sends a WS decision. */
+function useDecisionMutation(approved) {
+    const { send } = useApprovalsSocket();
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id, note }) => {
+        setIsPending(true);
+        try {
+            const ok = send({
+                type: 'tool_approval_decision',
+                approvalId: id,
+                approved,
+                ...(note ? { note } : {}),
+            });
+            if (!ok) {
+                throw new Error('Approvals WebSocket is not connected; decision was not sent');
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [approved, send]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
+}
 export function useApproveToolRequest() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id, note }) => toolApprovals.approveToolRequest(token, id, note, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useDecisionMutation(true);
 }
 export function useRejectToolRequest() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
+    return useDecisionMutation(false);
+}
+/**
+ * Mark a tool approval as read/unread in the local cache.
+ *
+ * Read-state isn't part of the websocket contract, so this hook patches
+ * only the React Query cache. The patch survives until the next snapshot.
+ */
+function useLocalReadMutation(target) {
     const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id, note }) => toolApprovals.rejectToolRequest(token, id, note, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id }) => {
+        setIsPending(true);
+        try {
+            const queries = queryClient
+                .getQueryCache()
+                .findAll({ queryKey: APPROVALS_ROOT_KEY });
+            for (const q of queries) {
+                const [, second] = q.queryKey;
+                if (second === 'pending-count')
+                    continue;
+                const current = queryClient.getQueryData(q.queryKey);
+                if (!current?.approvals)
+                    continue;
+                queryClient.setQueryData(q.queryKey, {
+                    ...current,
+                    approvals: current.approvals.map(a => a.id === id ? { ...a, read: target } : a),
+                });
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [queryClient, target]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
 }
 export function useMarkToolApprovalRead() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.markToolApprovalRead(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useLocalReadMutation(true);
 }
 export function useMarkToolApprovalUnread() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.markToolApprovalUnread(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    return useLocalReadMutation(false);
 }
+/**
+ * Delete a tool approval.
+ *
+ * Sends a ``tool_approval_delete`` message over the shared websocket.
+ * The local cache is updated only after the server emits
+ * ``tool_approval_deleted``.
+ */
 export function useDeleteToolApproval() {
-    const token = useDashboardAuthToken();
-    const baseUrl = useDashboardBaseUrl();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: ({ id }) => toolApprovals.deleteToolApproval(token, id, baseUrl),
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['tool-approvals'] });
-        },
-    });
+    const { send } = useApprovalsSocket();
+    const [isPending, setIsPending] = useState(false);
+    const mutateAsync = useCallback(async ({ id }) => {
+        setIsPending(true);
+        try {
+            const ok = send({
+                type: 'tool_approval_delete',
+                approvalId: id,
+            });
+            if (!ok) {
+                throw new Error('Approvals WebSocket is not connected; delete was not sent');
+            }
+        }
+        finally {
+            setIsPending(false);
+        }
+    }, [send]);
+    const mutate = useCallback((vars) => {
+        void mutateAsync(vars);
+    }, [mutateAsync]);
+    return { isPending, mutate, mutateAsync };
 }
 // ─── Composite hook ──────────────────────────────────────────────────
 export function useToolApprovals(filters) {

package/lib/hooks/useVercelAI.d.ts

@@ -6,7 +6,7 @@ export interface Message {
 }
 export interface UseVercelAIOptions {
     /**
-     * Base URL for the Vercel AI endpoint (e.g., 'http://localhost:8000')
+     * Base URL for the Vercel AI endpoint (e.g., `http://localhost:8000`).
      */
     baseUrl?: string;
     /**

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, BenchmarkSpec, 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

@@ -48,6 +48,13 @@ export declare class VercelAIAdapter extends BaseProtocolAdapter {
     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

@@ -33,6 +33,26 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
     _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;
@@ -175,12 +195,10 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                 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 &&
@@ -253,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;
@@ -399,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: {
@@ -406,6 +426,7 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                                                     success: true,
                                                     result: {
                                                         pending_approval: true,
+                                                        approval_id: approvalId,
                                                         message: 'Awaiting user approval',
                                                     },
                                                 },
@@ -499,6 +520,7 @@ 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);
@@ -529,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 ||
@@ -543,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 ||
@@ -598,6 +630,16 @@ 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',
@@ -657,7 +699,9 @@ export class VercelAIAdapter extends BaseProtocolAdapter {
                     ? resultObj.approvalId
                     : tr.toolCallId;
                 const approved = Boolean(resultObj?.approved);
-                const reason = typeof resultObj?.message === 'string' ? resultObj.message : undefined;
+                const reason = typeof resultObj?.message === 'string'
+                    ? resultObj.message
+                    : undefined;
                 assistantParts.push({
                     type: 'dynamic-tool',
                     toolName: tr.toolName,
@@ -714,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/specs/agents/agents.d.ts

@@ -14,11 +14,28 @@ 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 DEMO_FULL_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_SIMPLE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const DEMO_OUTPUTS_AGENT_SPEC_0_0_1: AgentSpec;
 export declare const END_OF_MONTH_SALES_PERFORMANCE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EVAL_EXPERIMENT_RUNNER_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_CODEMODE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_EVALS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_FULL_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_GUARDRAILS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_HOOKS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_INFERENCE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_MCP_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_MEMORY_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_MONITORING_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_NO_CODEMODE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_NOTIFICATIONS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_ONE_TRIGGER_APPROVAL_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_ONE_TRIGGER_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_OTEL_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_PARAMETERS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_SIMPLE_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_SKILLS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_SUBAGENTS_AGENT_SPEC_0_0_1: AgentSpec;
+export declare const EXAMPLE_TOOL_APPROVALS_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;
 export declare const FINANCIAL_AGENT_SPEC_0_0_1: AgentSpec;