feat: expose tool node artifacts to downstream nodes in Agentflow v2

packages/agentflow/src/features/node-editor/useAvailableVariables.test.tsx

@@ -63,9 +63,11 @@ describe('useAvailableVariables', () => {
         const { result } = renderHook(() => useAvailableVariables('agent_0'))
 
         const nodeOutputs = result.current.filter((i) => i.category === 'Node Outputs')
-        expect(nodeOutputs).toHaveLength(1)
+        expect(nodeOutputs).toHaveLength(2)
         expect(nodeOutputs[0].value).toBe('{{llm_0}}')
         expect(nodeOutputs[0].label).toBe('llm_0')
+        expect(nodeOutputs[1].value).toBe('{{llm_0.output.artifacts}}')
+        expect(nodeOutputs[1].label).toBe('llm_0.output.artifacts')
     })
 
     it('excludes startAgentflow from node outputs', () => {
@@ -96,6 +98,7 @@ describe('useAvailableVariables', () => {
 
         const nodeOutputs = result.current.filter((i) => i.category === 'Node Outputs')
         expect(nodeOutputs[0].label).toBe('myFunc')
+        expect(nodeOutputs[1].label).toBe('myFunc.output.artifacts')
     })
 
     it('returns flow state variables from startAgentflow node', () => {

packages/agentflow/src/features/node-editor/useAvailableVariables.ts

@@ -100,6 +100,14 @@ export function useAvailableVariables(nodeId: string): VariableItem[] {
                 icon: agentflowIcon?.icon,
                 iconColor: agentflowIcon?.color
             })
+            items.push({
+                label: `${displayName}.output.artifacts`,
+                description: `Artifacts from ${node.data.label ?? node.data.name}`,
+                category: 'Node Outputs',
+                value: `{{${node.id}.output.artifacts}}`,
+                icon: agentflowIcon?.icon,
+                iconColor: agentflowIcon?.color
+            })
         }
 
         // ── Flow state variables from all nodes ─────────────────────────

packages/components/nodes/agentflow/DirectReply/DirectReply.test.ts

@@ -0,0 +1,82 @@
+const { nodeClass: DirectReply_Agentflow } = require('./DirectReply')
+
+describe('DirectReply_Agentflow', () => {
+    const createNode = () => new DirectReply_Agentflow()
+    const createOptions = () => ({
+        agentflowRuntime: { state: { existing: 'state' } },
+        chatId: 'chat-1',
+        isLastNode: true,
+        sseStreamer: {
+            streamTokenEvent: jest.fn(),
+            streamArtifactsEvent: jest.fn()
+        }
+    })
+
+    it('returns text only when no artifacts are provided', async () => {
+        const node = createNode()
+        const options = createOptions()
+
+        const result = await node.run(
+            {
+                id: 'directReplyAgentflow_0',
+                inputs: { directReplyMessage: 'done' }
+            },
+            '',
+            options
+        )
+
+        expect(result.output).toEqual({ content: 'done' })
+        expect(options.sseStreamer.streamTokenEvent).toHaveBeenCalledWith('chat-1', 'done')
+        expect(options.sseStreamer.streamArtifactsEvent).not.toHaveBeenCalled()
+    })
+
+    it('attaches resolved artifacts from the artifacts input', async () => {
+        const node = createNode()
+        const options = createOptions()
+        const artifacts = [
+            { type: 'png', data: 'FILE-STORAGE::image.png' },
+            { type: 'pdf', data: 'FILE-STORAGE::report.pdf' }
+        ]
+
+        const result = await node.run(
+            {
+                id: 'directReplyAgentflow_0',
+                inputs: {
+                    directReplyMessage: 'generated files',
+                    directReplyArtifacts: JSON.stringify(artifacts)
+                }
+            },
+            '',
+            options
+        )
+
+        expect(result.output).toEqual({
+            content: 'generated files',
+            artifacts
+        })
+        expect(options.sseStreamer.streamTokenEvent).toHaveBeenCalledWith('chat-1', 'generated files')
+        expect(options.sseStreamer.streamArtifactsEvent).toHaveBeenCalledWith('chat-1', artifacts)
+    })
+
+    it('detects artifact-only messages without returning artifact JSON as content', async () => {
+        const node = createNode()
+        const options = createOptions()
+        const artifacts = [{ type: 'png', data: 'FILE-STORAGE::image.png' }]
+
+        const result = await node.run(
+            {
+                id: 'directReplyAgentflow_0',
+                inputs: { directReplyMessage: JSON.stringify(artifacts) }
+            },
+            '',
+            options
+        )
+
+        expect(result.output).toEqual({
+            content: ' ',
+            artifacts
+        })
+        expect(options.sseStreamer.streamTokenEvent).not.toHaveBeenCalled()
+        expect(options.sseStreamer.streamArtifactsEvent).toHaveBeenCalledWith('chat-1', artifacts)
+    })
+})

packages/components/nodes/agentflow/DirectReply/DirectReply.ts

@@ -1,4 +1,29 @@
 import { ICommonObject, INode, INodeData, INodeParams, IServerSideEventStreamer } from '../../../src/Interface'
+import { flatten } from 'lodash'
+
+const parseArtifacts = (value: unknown): ICommonObject[] => {
+    let artifacts = value
+
+    if (typeof artifacts === 'string') {
+        const trimmedValue = artifacts.trim()
+        if (!trimmedValue) return []
+
+        try {
+            artifacts = JSON.parse(trimmedValue)
+        } catch {
+            return []
+        }
+    }
+
+    const flattenedArtifacts = Array.isArray(artifacts) ? flatten(artifacts) : [artifacts]
+    return flattenedArtifacts.filter(
+        (artifact): artifact is ICommonObject =>
+            typeof artifact === 'object' &&
+            artifact !== null &&
+            typeof (artifact as ICommonObject).type === 'string' &&
+            typeof (artifact as ICommonObject).data === 'string'
+    )
+}
 
 class DirectReply_Agentflow implements INode {
     label: string
@@ -32,30 +57,50 @@ class DirectReply_Agentflow implements INode {
                 name: 'directReplyMessage',
                 type: 'string',
                 rows: 4,
-                acceptVariable: true
+                acceptVariable: true,
+                acceptNodeOutputAsVariable: true
+            },
+            {
+                label: 'Artifacts',
+                name: 'directReplyArtifacts',
+                type: 'string',
+                optional: true,
+                acceptVariable: true,
+                acceptNodeOutputAsVariable: true
             }
         ]
     }
 
     async run(nodeData: INodeData, _: string, options: ICommonObject): Promise<any> {
         const directReplyMessage = nodeData.inputs?.directReplyMessage as string
+        const directReplyArtifacts = nodeData.inputs?.directReplyArtifacts
 
         const state = options.agentflowRuntime?.state as ICommonObject
         const chatId = options.chatId as string
         const isLastNode = options.isLastNode as boolean
         const isStreamable = isLastNode && options.sseStreamer !== undefined
+        const artifacts = parseArtifacts(directReplyArtifacts)
+        const messageArtifacts = artifacts.length > 0 ? [] : parseArtifacts(directReplyMessage)
+        const resolvedArtifacts = artifacts.length > 0 ? artifacts : messageArtifacts
+        const outputContent = messageArtifacts.length > 0 && directReplyMessage?.trim() ? ' ' : directReplyMessage
 
         if (isStreamable) {
             const sseStreamer: IServerSideEventStreamer = options.sseStreamer
-            sseStreamer.streamTokenEvent(chatId, directReplyMessage)
+            if (outputContent?.trim()) {
+                sseStreamer.streamTokenEvent(chatId, outputContent)
+            }
+            if (resolvedArtifacts.length > 0) {
+                sseStreamer.streamArtifactsEvent(chatId, resolvedArtifacts)
+            }
         }
 
         const returnOutput = {
             id: nodeData.id,
             name: this.name,
             input: {},
             output: {
-                content: directReplyMessage
+                content: outputContent,
+                ...(resolvedArtifacts.length > 0 && { artifacts: resolvedArtifacts })
             },
             state
         }