@inkeep/agents-manage-ui 0.15.0 → 0.16.1

package/src/components/traces/timeline/timeline-item.tsx

@@ -107,7 +107,7 @@ export function TimelineItem({
   const textColorClass =
     activity.status === 'error'
       ? 'text-red-500 hover:text-red-700'
-        : 'text-foreground hover:text-primary';
+      : 'text-foreground hover:text-primary';
 
   return (
     <div className={`flex flex-col text-muted-foreground relative text-xs`}>
@@ -392,8 +392,8 @@ export function TimelineItem({
 
           {/* ai.telemetry.functionId badge for ai.toolCall spans that aren't delegate or transfers */}
           {activity.type === ACTIVITY_TYPES.TOOL_CALL &&
-            activity.aiTelemetryFunctionId && 
-            activity.toolType !== 'delegation' && 
+            activity.aiTelemetryFunctionId &&
+            activity.toolType !== 'delegation' &&
             activity.toolType !== 'transfer' && (
               <div className="mb-1">
                 <Badge variant="code" className="text-xs">
@@ -403,29 +403,28 @@ export function TimelineItem({
             )}
 
           {/* Error display for failed AI/Agent generations */}
-          {(activity.hasError) &&
-            activity.otelStatusDescription && (
-              <div className="space-y-2">
-                <button
-                  type="button"
-                  onClick={() => onToggleAiMessageCollapse && onToggleAiMessageCollapse(activity.id)}
-                  className="flex items-center gap-1 text-xs text-red-500 hover:text-red-600 transition-colors"
-                  title={isAiMessageCollapsed ? 'Expand error message' : 'Collapse error message'}
-                >
-                  {isAiMessageCollapsed ? (
-                    <ChevronRight className="h-3 w-3" />
-                  ) : (
-                    <ChevronDown className="h-3 w-3" />
-                  )}
-                  Error Details
-                </button>
-                {!isAiMessageCollapsed && (
-                  <Bubble className="bg-red-50 border-red-200 text-red-800 dark:bg-red-900/20 dark:border-red-800 dark:text-red-300">
-                    {activity.otelStatusDescription}
-                  </Bubble>
+          {activity.hasError && activity.otelStatusDescription && (
+            <div className="space-y-2">
+              <button
+                type="button"
+                onClick={() => onToggleAiMessageCollapse?.(activity.id)}
+                className="flex items-center gap-1 text-xs text-red-500 hover:text-red-600 transition-colors"
+                title={isAiMessageCollapsed ? 'Expand error message' : 'Collapse error message'}
+              >
+                {isAiMessageCollapsed ? (
+                  <ChevronRight className="h-3 w-3" />
+                ) : (
+                  <ChevronDown className="h-3 w-3" />
                 )}
-              </div>
-            )}
+                Error Details
+              </button>
+              {!isAiMessageCollapsed && (
+                <Bubble className="bg-red-50 border-red-200 text-red-800 dark:bg-red-900/20 dark:border-red-800 dark:text-red-300">
+                  {activity.otelStatusDescription}
+                </Bubble>
+              )}
+            </div>
+          )}
 
           <time
             className="text-xs mb-2 inline-block text-gray-500 dark:text-white/50"

package/src/components/traces/timeline/timeline-wrapper.tsx

@@ -1,5 +1,5 @@
 import { AlertTriangle, ChevronDown, ChevronUp, Loader2, RefreshCw } from 'lucide-react';
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { toast } from 'sonner';
 import { StickToBottom } from 'use-stick-to-bottom';
 import { ConversationTracesLink } from '@/components/traces/signoz-link';
@@ -224,19 +224,49 @@ export function TimelineWrapper({
       .map((activity) => activity.id);
   }, [sortedActivities]);
 
-  // Initialize AI messages based on view type when activities change
+  // Track which messages we've already processed
+  const processedIdsRef = useRef<Set<string>>(new Set());
+  const lastConversationRef = useRef<string | undefined>(undefined);
+  
   useEffect(() => {
-    if (enableAutoScroll) {
-      // Live trace view: collapse all AI messages
-      setCollapsedAiMessages(new Set(aiMessageIds));
-      setAiMessagesGloballyCollapsed(true);
-    } else {
-      // Conversation details view: collapse only ai.streamText.doStream spans
-      setCollapsedAiMessages(new Set(streamTextIds));
-      setAiMessagesGloballyCollapsed(streamTextIds.length === aiMessageIds.length);
+    // Reset when conversation changes
+    if (conversationId !== lastConversationRef.current) {
+      lastConversationRef.current = conversationId;
+      processedIdsRef.current = new Set();
+      setCollapsedAiMessages(new Set());
+      setAiMessagesGloballyCollapsed(false);
     }
-  }, [aiMessageIds, streamTextIds, enableAutoScroll]);
-
+    
+    // Determine which IDs to auto-collapse based on view type
+    const idsToProcess = enableAutoScroll ? aiMessageIds : streamTextIds;
+    
+    // Find new IDs that haven't been processed yet
+    const newIds = idsToProcess.filter(id => !processedIdsRef.current.has(id));
+    
+    if (newIds.length > 0) {
+      // Mark these as processed
+      newIds.forEach(id => {
+        processedIdsRef.current.add(id);
+      });
+      
+      // Add new IDs to collapsed set
+      setCollapsedAiMessages(prev => {
+        const updated = new Set(prev);
+        newIds.forEach(id => {
+          updated.add(id);
+        });
+        return updated;
+      });
+      // Update global state
+      const allProcessed = idsToProcess.every(id => processedIdsRef.current.has(id));
+      if (enableAutoScroll) {
+        setAiMessagesGloballyCollapsed(allProcessed && aiMessageIds.length > 0);
+      } else {
+        setAiMessagesGloballyCollapsed(allProcessed && streamTextIds.length === aiMessageIds.length && aiMessageIds.length > 0);
+      }
+    }
+  }, [conversationId, aiMessageIds, streamTextIds, enableAutoScroll]);
+  
   // Functions to handle expand/collapse all (memoized to prevent unnecessary re-renders)
   const expandAllAiMessages = useCallback(() => {
     setCollapsedAiMessages(new Set());

package/src/components/traces/traces-overview.tsx

@@ -1,11 +1,13 @@
 'use client';
 
-import { ArrowRightLeft, RefreshCw, SparklesIcon, Users, Wrench } from 'lucide-react';
+import { AlertTriangle, ArrowRightLeft, SparklesIcon, Users, Wrench } from 'lucide-react';
 import { useParams, useRouter, useSearchParams } from 'next/navigation';
 import { useEffect, useMemo, useState } from 'react';
-import { Button } from '@/components/ui/button';
+import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert';
 import { Card, CardContent } from '@/components/ui/card';
+import { ExternalLink } from '@/components/ui/external-link';
 import { useAggregateStats, useConversationStats } from '@/hooks/use-traces';
+import { useSignozConfig } from '@/hooks/use-signoz-config';
 import { type TimeRange, useTracesQueryState } from '@/hooks/use-traces-query-state';
 import { getSigNozStatsClient, type SpanFilterOptions } from '@/lib/api/signoz-stats';
 import { AreaChartCard } from './charts/area-chart-card';
@@ -14,6 +16,7 @@ import { ConversationStatsCard } from './conversation-stats/conversation-stats-c
 import { CUSTOM, DatePickerWithPresets } from './filters/date-picker';
 import { GraphFilter } from './filters/graph-filter';
 import { SpanFilters } from './filters/span-filters';
+import { DOCS_BASE_URL } from '@/constants/page-descriptions';
 
 // Time range options
 const TIME_RANGES = {
@@ -42,6 +45,9 @@ export function TracesOverview({ refreshKey }: TracesOverviewProps) {
     setSpanFilter,
   } = useTracesQueryState();
 
+  // Check if Signoz is configured
+  const { isLoading: isSignozConfigLoading, configError: signozConfigError } = useSignozConfig();
+
   const [selectedGraph, setSelectedGraph] = useState<string | undefined>(undefined);
   const [searchQuery, setSearchQuery] = useState<string>('');
   const [debouncedSearchQuery, setDebouncedSearchQuery] = useState<string>('');
@@ -296,31 +302,46 @@ export function TracesOverview({ refreshKey }: TracesOverviewProps) {
 
   return (
     <div className="space-y-4">
-      <div className="flex items-center justify-between">
-        <div className="flex items-center gap-4">
-          {/* Graph Filter */}
-          <GraphFilter onSelect={setSelectedGraph} selectedValue={selectedGraph} />
-          {/* Time Range Filter */}
-          <DatePickerWithPresets
-            label="Time range"
-            onRemove={() => setSelectedTimeRange('15d')}
-            value={
-              selectedTimeRange === CUSTOM
-                ? { from: customStartDate, to: customEndDate }
-                : selectedTimeRange
-            }
-            onAdd={(value: TimeRange) => setSelectedTimeRange(value)}
-            setCustomDateRange={(start: string, end: string) => setCustomDateRange(start, end)}
-            options={Object.entries(TIME_RANGES).map(([value, config]) => ({
-              value,
-              label: config.label,
-            }))}
-          />
-        </div>
-        <Button variant="outline" size="sm" onClick={refresh}>
-          <RefreshCw className="h-4 w-4" />
-          Refresh
-        </Button>
+      {/* Signoz Configuration Banner */}
+      {!isSignozConfigLoading && signozConfigError && (
+        <Alert variant="warning">
+          <AlertTriangle className="h-4 w-4" />
+          <AlertTitle>SigNoz Configuration Error</AlertTitle>
+          <AlertDescription>
+            <p>
+              {signozConfigError} Please follow the instructions in the{' '}
+              <ExternalLink
+                className="text-amber-700 dark:text-amber-300 dark:hover:text-amber-200"
+                iconClassName="text-amber-700 dark:text-amber-300 dark:group-hover/link:text-amber-200"
+                href={`${DOCS_BASE_URL}/quick-start/traces`}
+              >
+                traces setup guide
+              </ExternalLink>
+              .
+            </p>
+          </AlertDescription>
+        </Alert>
+      )}
+
+      <div className="flex items-center gap-4">
+        {/* Graph Filter */}
+        <GraphFilter onSelect={setSelectedGraph} selectedValue={selectedGraph} />
+        {/* Time Range Filter */}
+        <DatePickerWithPresets
+          label="Time range"
+          onRemove={() => setSelectedTimeRange('15d')}
+          value={
+            selectedTimeRange === CUSTOM
+              ? { from: customStartDate, to: customEndDate }
+              : selectedTimeRange
+          }
+          onAdd={(value: TimeRange) => setSelectedTimeRange(value)}
+          setCustomDateRange={(start: string, end: string) => setCustomDateRange(start, end)}
+          options={Object.entries(TIME_RANGES).map(([value, config]) => ({
+            value,
+            label: config.label,
+          }))}
+        />
       </div>
 
       <div className="flex flex-col gap-4">

package/src/constants/signoz.ts

@@ -63,7 +63,7 @@ export const SPAN_KEYS = {
   CONTEXT_URL: 'context.url',
   CONTEXT_CONFIG_ID: 'context.context_config_id',
   CONTEXT_AGENT_GRAPH_ID: 'context.agent_graph_id',
-  CONTEXT_REQUEST_KEYS: 'context.request_context_keys',
+  CONTEXT_HEADERS_KEYS: 'context.headers_keys',
 
   // Message attributes
   MESSAGE_CONTENT: 'message.content',

package/src/features/graph/domain/__tests__/roundtrip.test.ts

@@ -54,10 +54,8 @@ describe('graph serialize/deserialize', () => {
       description: 'Graph with self-referencing agent',
       contextConfig: {
         id: '',
-        name: '',
-        description: '',
         contextVariables: '',
-        requestContextSchema: '',
+        headersSchema: '',
       },
     });
 
@@ -139,10 +137,8 @@ describe('graph serialize/deserialize', () => {
       name: 'G',
       description: 'D',
       contextConfig: {
-        name: 'Context',
-        description: 'Context description',
         contextVariables: '{}',
-        requestContextSchema: '{}',
+        headersSchema: '{}',
       },
     });
     expect(serialized.id).toBe('g1');

package/src/features/graph/domain/__tests__/serialize.test.ts

@@ -236,7 +236,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: ['tool1', 'tool2'],
-        headers: {},
+        headers: null,
       });
     });
 
@@ -282,7 +282,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: null,
-        headers: {},
+        headers: null,
       });
     });
 
@@ -326,7 +326,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: [],
-        headers: {},
+        headers: null,
       });
     });
 
@@ -413,7 +413,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
         toolSelection: null, // null means all tools are selected
-        headers: {},
+        headers: null,
       });
     });
   });

package/src/features/graph/domain/deserialize.ts

@@ -6,6 +6,7 @@ import {
   agentNodeSourceHandleId,
   agentNodeTargetHandleId,
   externalAgentNodeTargetHandleId,
+  functionToolNodeHandleId,
   mcpNodeHandleId,
   NodeType,
 } from '@/components/graph/configuration/node-types';
@@ -200,32 +201,65 @@ export function deserializeGraphData(data: FullGraphDefinition): TransformResult
     nodes.push(agentNode);
   }
 
-  // Note: Tools are now project-scoped and not included in graph data
-  // Tool visualization will need to be handled at the project level
+  // Create tool nodes from canUse items (using tools and functions lookups)
   for (const agentId of agentIds) {
     const agent = data.agents[agentId];
     // Check if agent has canUse property (internal agents)
     if ('canUse' in agent && agent.canUse && agent.canUse.length > 0) {
-      // Tools are project-scoped - create nodes from canUse items
       for (const canUseItem of agent.canUse) {
         const toolId = canUseItem.toolId;
         const toolNodeId = nanoid();
         const relationshipId = canUseItem.agentToolRelationId;
+
+        // Look up the tool to get its details
+        const tool = data.tools?.[toolId];
+        const toolType = tool?.config?.type || 'mcp'; // Default to MCP if not found
+
+        // Create the appropriate node type
+        const nodeType = toolType === 'function' ? NodeType.FunctionTool : NodeType.MCP;
+
+        // Populate node data with tool details from lookup
+        const nodeData: any = {
+          toolId,
+          agentId,
+          relationshipId,
+          // Add tool details from lookup for proper display
+          name: tool?.name,
+          description: tool?.description,
+          imageUrl: (tool as any)?.imageUrl,
+        };
+
+        // For function tools, add function details from functions lookup
+        if (toolType === 'function') {
+          const functionId = (tool as any)?.functionId;
+          if (functionId) {
+            const func = data.functions?.[functionId];
+            if (func) {
+              nodeData.inputSchema = func.inputSchema;
+              nodeData.code = func.executeCode;
+              nodeData.dependencies = func.dependencies;
+            }
+          }
+        }
+
         const toolNode: Node = {
           id: toolNodeId,
-          type: NodeType.MCP,
+          type: nodeType,
           position: { x: 0, y: 0 },
-          data: { toolId, agentId, relationshipId },
+          data: nodeData,
         };
         nodes.push(toolNode);
 
+        // Use the appropriate handle ID based on tool type
+        const targetHandle = toolType === 'function' ? functionToolNodeHandleId : mcpNodeHandleId;
+
         const agentToToolEdge: Edge = {
           id: `edge-${toolNodeId}-${agentId}`,
           type: EdgeType.Default,
           source: agentId,
           sourceHandle: agentNodeSourceHandleId,
           target: toolNodeId,
-          targetHandle: mcpNodeHandleId,
+          targetHandle,
         };
         edges.push(agentToToolEdge);
       }

package/src/features/graph/domain/graph-initializer-helpers.ts

@@ -3,9 +3,9 @@ import type { FullGraphDefinition } from '@/lib/types/graph-full';
 import { formatJsonField } from '@/lib/utils';
 
 export type ExtendedFullGraphDefinition = FullGraphDefinition & {
-  contextConfig?: Partial<Pick<ContextConfig, 'id' | 'name' | 'description'>> & {
+  contextConfig?: Partial<Pick<ContextConfig, 'id'>> & {
     contextVariables?: Record<string, any>;
-    requestContextSchema?: Record<string, any>;
+    headersSchema?: Record<string, any>;
   };
 };
 
@@ -54,10 +54,8 @@ export function extractGraphMetadata(
       : undefined,
     contextConfig: {
       id: graph?.contextConfig?.id ?? '',
-      name: graph?.contextConfig?.name ?? '',
-      description: graph?.contextConfig?.description ?? '',
       contextVariables: formatJsonField(graph?.contextConfig?.contextVariables) || '',
-      requestContextSchema: formatJsonField(graph?.contextConfig?.requestContextSchema) || '',
+      headersSchema: formatJsonField(graph?.contextConfig?.headersSchema) || '',
     },
   };
 }

package/src/features/graph/domain/serialize.ts

@@ -115,11 +115,11 @@ export function serializeGraphData(
 
       const stopWhen = (node.data as any).stopWhen;
 
-      // Build canUse array from edges connecting this agent to MCP nodes
+      // Build canUse array from edges connecting this agent to tool nodes (MCP and Function)
       const canUse: Array<{
         toolId: string;
         toolSelection?: string[] | null;
-        headers?: Record<string, string>;
+        headers?: Record<string, string> | null;
         agentToolRelationId?: string;
       }> = [];
 
@@ -165,7 +165,7 @@ export function serializeGraphData(
             }
 
             const tempHeaders = (mcpNode.data as any).tempHeaders;
-            let toolHeaders: Record<string, string> = {};
+            let toolHeaders: Record<string, string> | null = null;
 
             if (tempHeaders !== undefined) {
               if (
@@ -195,6 +195,35 @@ export function serializeGraphData(
         }
       }
 
+      // Find edges from this agent to Function Tool nodes
+      const agentToFunctionToolEdges = edges.filter(
+        (edge) =>
+          edge.source === node.id &&
+          nodes.some((n) => n.id === edge.target && n.type === NodeType.FunctionTool)
+      );
+
+      for (const edge of agentToFunctionToolEdges) {
+        const functionToolNode = nodes.find((n) => n.id === edge.target);
+
+        if (functionToolNode && functionToolNode.type === NodeType.FunctionTool) {
+          const nodeData = functionToolNode.data as any;
+          const toolId = nodeData.toolId;
+
+          if (toolId) {
+            // Get the relationshipId if it exists
+            const relationshipId = nodeData.relationshipId;
+
+            // Function tools use the same simple structure as MCP tools
+            canUse.push({
+              toolId,
+              toolSelection: null, // Function tools don't have tool selection
+              headers: null, // Function tools don't have headers
+              ...(relationshipId && { agentToolRelationId: relationshipId }),
+            });
+          }
+        }
+      }
+
       const agent: ExtendedAgent = {
         id: agentId,
         name: node.data.name as string,
@@ -295,20 +324,18 @@ export function serializeGraphData(
 
   const parsedContextVariables = safeJsonParse(metadata?.contextConfig?.contextVariables);
 
-  const parsedRequestContextSchema = safeJsonParse(metadata?.contextConfig?.requestContextSchema);
+  const parsedHeadersSchema = safeJsonParse(metadata?.contextConfig?.headersSchema);
 
   const hasContextConfig =
     metadata?.contextConfig &&
-    ((metadata.contextConfig.name && metadata.contextConfig.name.trim() !== '') ||
-      (metadata.contextConfig.description && metadata.contextConfig.description.trim() !== '') ||
-      (parsedContextVariables &&
-        typeof parsedContextVariables === 'object' &&
-        parsedContextVariables !== null &&
-        Object.keys(parsedContextVariables).length > 0) ||
-      (parsedRequestContextSchema &&
-        typeof parsedRequestContextSchema === 'object' &&
-        parsedRequestContextSchema !== null &&
-        Object.keys(parsedRequestContextSchema).length > 0));
+    ((parsedContextVariables &&
+      typeof parsedContextVariables === 'object' &&
+      parsedContextVariables !== null &&
+      Object.keys(parsedContextVariables).length > 0) ||
+      (parsedHeadersSchema &&
+        typeof parsedHeadersSchema === 'object' &&
+        parsedHeadersSchema !== null &&
+        Object.keys(parsedHeadersSchema).length > 0));
 
   const dataComponents: Record<string, DataComponent> = {};
   if (dataComponentLookup) {
@@ -387,9 +414,7 @@ export function serializeGraphData(
     (result as any).contextConfigId = contextConfigId;
     (result as any).contextConfig = {
       id: contextConfigId,
-      name: metadata.contextConfig.name || '',
-      description: metadata.contextConfig.description || '',
-      requestContextSchema: parsedRequestContextSchema,
+      headersSchema: parsedHeadersSchema,
       contextVariables: parsedContextVariables,
     };
   }
@@ -419,6 +444,40 @@ export function validateSerializedData(data: FullGraphDefinition): string[] {
       }
     }
 
+    // Validate function tools for internal agents (check canUse array for function tools)
+    if ('canUse' in agent && agent.canUse) {
+      for (const canUseItem of agent.canUse) {
+        const toolId = canUseItem.toolId;
+        const toolType = (canUseItem as any).toolType;
+
+        // Only validate function tools
+        if (toolType === 'function') {
+          const functionTool = (canUseItem as any).functionTool;
+
+          if (!functionTool) {
+            errors.push(
+              `Function tool '${toolId}' referenced by agent '${agentId}' is missing function tool data`
+            );
+            continue;
+          }
+
+          // Validate required fields for function tools
+          if (!functionTool.name || String(functionTool.name).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: name`);
+          }
+          if (!functionTool.description || String(functionTool.description).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: description`);
+          }
+          if (!functionTool.executeCode || String(functionTool.executeCode).trim() === '') {
+            errors.push(`Function tool '${toolId}' is missing required field: executeCode`);
+          }
+          if (!functionTool.inputSchema || Object.keys(functionTool.inputSchema).length === 0) {
+            errors.push(`Function tool '${toolId}' is missing required field: inputSchema`);
+          }
+        }
+      }
+    }
+
     // Only validate relationships for internal agents (external agents don't have these properties)
     if ('canTransferTo' in agent) {
       for (const targetId of agent.canTransferTo ?? []) {

package/src/features/graph/state/use-graph-store.ts

@@ -76,10 +76,8 @@ export const graphStore = create<GraphState>()(
       name: '',
       description: '',
       contextConfig: {
-        name: '',
-        description: '',
         contextVariables: '',
-        requestContextSchema: '',
+        headersSchema: '',
       },
       models: undefined,
       stopWhen: undefined,

package/src/hooks/use-signoz-config.ts

@@ -0,0 +1,36 @@
+import { useEffect, useState } from 'react';
+
+interface SignozConfigStatus {
+  status: string;
+  configured: boolean;
+  error?: string;
+}
+
+export function useSignozConfig() {
+  const [isLoading, setIsLoading] = useState(true);
+  const [configError, setConfigError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const checkConfig = async () => {
+      try {
+        setIsLoading(true);
+        const response = await fetch('/api/signoz');
+        if (!response.ok) {
+          throw new Error('Failed to check Signoz configuration');
+        }
+        const data: SignozConfigStatus = await response.json();
+        setConfigError(data.error || null);
+      } catch (err) {
+        console.error('Error checking Signoz configuration:', err);
+        setConfigError(err instanceof Error ? err.message : 'Failed to check SigNoz configuration');
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    checkConfig();
+  }, []);
+
+  return { isLoading, configError };
+}
+

package/src/lib/__tests__/context-suggestions.test.ts

@@ -4,7 +4,7 @@ import { getContextSuggestions } from '../context-suggestions';
 
 describe('getContextSuggestions', () => {
   const mockContextSchema = {
-    requestContextSchema: {
+    headersSchema: {
       type: 'object',
       properties: {
         user_id: { type: 'string' },
@@ -38,9 +38,9 @@ describe('getContextSuggestions', () => {
   it('should return all expected suggestions', () => {
     const suggestions = getContextSuggestions(mockContextSchema);
     expect(suggestions).toStrictEqual([
-      'requestContext.auth_token',
-      'requestContext.org_name',
-      'requestContext.user_id',
+      'headers.auth_token',
+      'headers.org_name',
+      'headers.user_id',
       'userName',
       'userName.name',
       'userName.preferences',
@@ -187,11 +187,11 @@ describe('getContextSuggestions', () => {
             responseSchema: z.toJSONSchema(settingsSchema),
           },
         },
-        requestContextSchema: z.toJSONSchema(z.object({ apiKey: z.string() })),
+        headersSchema: z.toJSONSchema(z.object({ apiKey: z.string() })),
       });
       expect(suggestions).toMatchInlineSnapshot(`
         [
-          "requestContext.apiKey",
+          "headers.apiKey",
           "settings",
           "settings.locale",
           "settings.theme",