ReAct Agent

 
  type SearchAgentPrepOut = {
    history: any[]; //Todo : type should be openaiMessage[], as we convert before passing
    cascadeId: string;
  };
  
  
  export const searchAgentNode: StreamingServerNodeDefinition<SearchAgentPrepOut> = {
    name: 'searchAgentNode',
    isUINode: false,
    env: 'server',
    isStreaming: true,
  
    async prep(cascadeContext: WorkflowContext, initialContext: any): Promise<SearchAgentPrepOut> {
        const cascadeId = initialContext.cascadeId;
        const dataArray = cascadeContext[cascadeId];
        const canonicalHistory = dataArray.flatMap((item: any) => item.history || []);
 
        /* 
           
           This history is in canonical shape (unless another canonical shape is forced
           by using a custom mapper, which are not doing in this example).
           So, we will convert to provider specific shape, using openai here.
 
        */
        const history = toProviderHistory('openai', canonicalHistory);    
 
        return { history, cascadeId };
      },
  
    async exec(prepOutput: SearchAgentPrepOut, controller?: CascadeController): Promise<StreamConfig> {
      const { history } = prepOutput;
 
      /*
          We are not using the controller in this example. Every `exec` gets one, and it allows you
          to control the graph execution from within nodes (delegation, recursion, pausing the node for some condition, etc.)
 
          See: Recursive ReAct Agent for concrete examples
      */
 
      const systemPrompt = `
            
      You are an expert technical AI assistant equipped with web search capabilities.
            You have access to the following tools:
            1. search_tool
            Use for general web searches, finding documentation, or retrieving facts.
            Pass a clear, concise query.
 
      `.trim();
 
      /*
             We will construct the tools here. We will write the tool definitions in `ToolParam` shape and 
             convert it into provider specific shape using `buildTools` helper.
      */
 
        const searchToolParams: ToolParam[] = [
                {
                  name:        'search_tool',
                  description: 'Searches the web using the input query.',
                  parameters: {
                    type: 'object' as const,
                    properties: {
                      query: { type: 'string', description: 'The natural language query' },
                    },
                    required: ['query'],
                  },
                },
              ];
 
      const openaiTools = buildTools('openai', searchToolParams);
      const {stream, provider} = await callLLM('openai', 'gpt-5.4-nano', systemPrompt, history, geminiTools,  true);
      return { stream, provider };
    },
  
    async post(execOutput: StreamingExecOutput): Promise<PostResult> {
      const { assistantMessage, uiAssistantMessage, history, cascadeId, userId } = execOutput;
 
      const pendingToolCalls = assistantMessage.tool_calls ?? [] as CanonicalToolCall[]
 
      /*
        if you had a filter set up in `StreamConfig`, the two `assistantMessage`s would differ.
        By passing an optional `uiUpdate`, you can censor what the client side sees even when hydrating 
        the cascade in new user sessions. Otherwise, the client would be censored only during the stream,
        and upon hydrating the cascade later, the full sensitive `Update` will hit the client.
 
      */
 
      const isDifferent = uiAssistantMessage !== undefined &&
      JSON.stringify(assistantMessage) !== JSON.stringify(uiAssistantMessage);
  
      return {
        updates: {
          [cascadeId as string]: {
            history:    [assistantMessage as CanonicalMessage],
            status:     pendingToolCalls.length > 0 ? 'calling_tool' : 'complete',
            lastUpdate: Date.now(),
            //you can add more fields if you want, it will be written to the cascade state
            // what's mandatory is history and status
          },
        } as Updates,
        ...(isDifferent ? {
          uiUpdates: {
            [cascadeId as string]: { history: [uiAssistantMessage as CanonicalMessage], status: pendingToolCalls.length > 0 ? 'calling_tool' : 'complete' },
          },
        } : {}),
        spawns: pendingToolCalls.length > 0
          ? {  // we spawn the hardcoded searchToolNode if there are tool calls
              ['searchToolNode']: {
                history:            [assistantMessage],
                toolCallsToExecute: pendingToolCalls,
                cascadeId,
              },
            } as Spawns
          : undefined,
 
          /*
             Some behaviours worth noting when spawning nodes
 
              - no cascadeId => this spawn is not part of a cascade, ephemeral, no persistence.
                Useful when you need one of fire and forget nodes, that do not need to be persisted.
                They are ghosts -> cannot write to state, but could spawn new nodes.
                This is mostly used to spawn observer UI nodes to watch cascades and/or initiate new ones.
 
              - no userId => safe to omit. the new node will inherit from the parent.
                Then why is it available in `initialContext` and `post`?
                userIds enter the nodes because you might need it for retrieving memories, or other scoped operations.
          */
      };
 
  }
  };
 

const cascadeId = initialContext.cascadeId;
const dataArray = cascadeContext[cascadeId];
const canonicalHistory = dataArray.flatMap((item: any) => item.history || []);
const history = toProviderHistory('openai', canonicalHistory);    
 

type StreamingExecOutput = {
    assistantMessage: any;
    uiAssistantMessage?: any;
    cascadeId?: string;
    history: any[];
    userId?: string;
}

 type SearchToolPrepOut = {
    toolCallsToExecute : CanonicalToolCall[];
    cascadeId: string;
  }
 
  type SearchToolExecOut = {
    results: CanonicalMessage[];
    cascadeId: string;
  }
  import { tavily } from "@tavily/core";
 
 
  const tvly = tavily({ apiKey: process.env.TAVILY_API_KEY });
 
 
 
  export const searchToolNode: ServerNodeDefinition<SearchToolPrepOut, SearchToolExecOut> = {
    name: 'searchToolNode',
    isUINode: false,
    env: 'server',
    isStreaming: false,
 
    async prep(cascadeContext: WorkflowContext, initialContext: any): Promise<SearchToolPrepOut> {
        const { toolCallsToExecute, cascadeId } = initialContext
        /*
            We simply pass what the `exec` step requires, not much preparation needed.
        */
        return { toolCallsToExecute: toolCallsToExecute ?? [], cascadeId};
 
    },
 
    async exec(prepOutput: SearchToolPrepOut, controller?: CascadeController ) : Promise<SearchToolExecOut> {
 
        const {toolCallsToExecute, cascadeId} = prepOutput;
        const results = await executeToolCalls(toolCallsToExecute, {
            search_tool: async ({ query }) => { return await tvly.search(query, {
                searchDepth: "basic",
                maxResults: 5,
                topic: "general"
              });}
          }, 'openai');
          const toolResultMessages = results.map(({ toolResult }) => toolResult);
 
        return {results: toolResultMessages, cascadeId}
 
    },
 
    async post(execOutput: SearchToolExecOut) : Promise<PostResult> {
 
        const {results, cascadeId} = execOutput;
        return {
            updates: {
              [cascadeId as string]: {
                history:    results,
                status:     'complete',
                //you can add more fields if you want, it will be written to the cascade state
                // what's mandatory is history and status
              },
            } as Updates,
            spawns :{
                ['searchAgentNode'] :  {
                    history:            results,
                    cascadeId,
                  },
                } as Spawns
            }
 
 
    }
  }

 
export type ManualToolExecute = (args: Record<string, any>) => Promise<unknown>;
export type ManualToolExecuteMap = Record<string, ManualToolExecute>;
 
export async function executeToolCalls(
  calls: CanonicalToolCall[],
  executeMap: ManualToolExecuteMap,
  provider: LLMProvider,
): Promise<{ toolCall:CanonicalToolCall; toolResult: CanonicalMessage }[]> {
  return Promise.all(
    calls.map(async (toolCall) => {
      const executeFn = executeMap[toolCall.name];
 
      if (!executeFn) {
        return {
          toolCall,
          toolResult: buildErrorToolResultMessage(provider, toolCall, `Unknown tool: ${toolCall.name}`),
        };
      }
 
      try {
        const rawResult = await executeFn(toolCall.args);
        return {
          toolCall,
          toolResult: buildToolResultMessage(provider, toolCall, rawResult),
        };
      } catch (err: any) {
        return {
          toolCall,
          toolResult: buildErrorToolResultMessage(provider, toolCall, err.message),
        };
      }
    })
  );
}