added AI orchestration , preprocessor options in client, bug fixes, docs updates

- DuckDuckGoSearchTool and HttpNode bug fixes
- AI Data Processing Node new AI orchestration functionality
- preprocessor options for client
- bug fixes
- docs updates

Author: code-forge-temple

client/src/components/nodes/LlmProcessNode/LlmProcessNode.tsx

@@ -57,6 +57,7 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
         think,
         temperatureEnabled,
         temperature,
+        orchestrationMode,
         onResultUpdate,
         onConfigChange,
         onFeedbackSend
@@ -146,6 +147,7 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
                         ragHandler,
                         think: think ?? defaultLlmProcessNodeData.think,
                         temperature: temperatureEnabled ? (temperature ?? defaultLlmProcessNodeData.temperature) : undefined,
+                        orchestrationMode: orchestrationMode ?? defaultLlmProcessNodeData.orchestrationMode,
                         conversationHistory: {
                             value: conversationHistory || [],
                             onChange: (newHistory) => {
@@ -179,6 +181,7 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
                     ragHandler,
                     think: think ?? defaultLlmProcessNodeData.think,
                     temperature: temperatureEnabled ? (temperature ?? defaultLlmProcessNodeData.temperature) : undefined,
+                    orchestrationMode: orchestrationMode ?? defaultLlmProcessNodeData.orchestrationMode,
                     conversationHistory: {
                         value: [],
                         onChange: (newHistory) => {
@@ -209,6 +212,7 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
                 ragHandler,
                 think: think ?? defaultLlmProcessNodeData.think,
                 temperature: temperatureEnabled ? (temperature ?? defaultLlmProcessNodeData.temperature) : undefined,
+                orchestrationMode: orchestrationMode ?? defaultLlmProcessNodeData.orchestrationMode,
                 conversationHistory: {
                     value: [],
                     onChange: (newHistory) => {
@@ -218,7 +222,7 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
             });
         }, setIsRunning);
     // eslint-disable-next-line max-len
-    }, [clearError, feedback, format, id, input, maxToolRetries, message, model, onConfigChange, onResultUpdate, processAIRequest, prompt, ragHandler, temperature, temperatureEnabled, think, tools]);
+    }, [clearError, feedback, format, id, input, maxToolRetries, message, model, onConfigChange, onResultUpdate, processAIRequest, prompt, ragHandler, temperature, temperatureEnabled, think, tools, orchestrationMode]);
 
     const [systemPrompt, setSystemPrompt] = useDebouncedState({
         callback: (value: string) => {
@@ -229,10 +233,10 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
     });
     const [messagePrefix, setMessagePrefix] = useDebouncedState({
         callback: (value: string) => {
-            onConfigChange(id, {message: {...message, preffix: value}});
+            onConfigChange(id, {message: {...message, prefix: value}});
         },
         delay: 300,
-        initialValue: message?.preffix || ""
+        initialValue: message?.prefix || ""
     });
     const [messageSuffix, setMessageSuffix] = useDebouncedState({
         callback: (value: string) => {
@@ -369,6 +373,18 @@ export function LlmProcessNode ({data, id}: NodeProps<AppNode>) {
                         sx={{mb: 2}}
                         helperText="Maximum number of retry attempts for each required tool"
                     />
+                    <Box sx={{display: 'flex', alignItems: 'center', justifyContent: 'space-between', mb: 1, ml: 1.5}}>
+                        <FormControlLabel
+                            control={
+                                <Switch
+                                    size="small"
+                                    checked={orchestrationMode ?? defaultLlmProcessNodeData.orchestrationMode}
+                                    onChange={e => onConfigChange(id, {orchestrationMode: e.target.checked})}
+                                />
+                            }
+                            label={<Typography variant="body2">AI Orchestration Mode</Typography>}
+                        />
+                    </Box>
                     <Box sx={{display: 'flex', alignItems: 'center', justifyContent: 'space-between', mb: 1, ml: 1.5}}>
                         <FormControlLabel
                             control={

client/src/components/nodes/LlmProcessNode/descriptor.ts

@@ -19,7 +19,8 @@ export const LlmProcessNodeDescriptor: NodeDescriptor<typeof NODE_TYPE, LlmProce
     title: TITLE,
     assertion: assertIsLlmProcessNodeData,
     metadata: {
-        description: "Sends data to an Ollama LLM with a configurable prompt. Supports tool calling, feedback loops, and conversation history.",
+        // eslint-disable-next-line max-len
+        description: "Sends data to an Ollama LLM with a configurable prompt. Supports tool calling, feedback loops, and conversation history. When 'AI Orchestration Mode' is enabled, an AI orchestrator decomposes the input (string or array) into individual sequential agent tasks and synthesizes a final aggregated response.",
         ports: {
             [NODE_PORT_IDS.FLOW]: {
                 inputSchema: z.any().describe("Incoming data, tools, and context for prompt execution."),

client/src/components/nodes/LlmProcessNode/hooks/useAIProcessor.ts

@@ -5,88 +5,19 @@
  ************************************************************************/
 
 import {useState, useCallback} from 'react';
-import {OllamaService} from '../../../../services/ollamaService';
 import {GenericNodeData} from '../../../../types/workflow';
 import {Message, MessageRole, SystemUserConfigValues, ToolSchema} from '../../../../types/ollama.types';
-import Ajv from "ajv";
 import {LlmProcessNodeData} from '../types/workflow';
 import {useFetchModels} from '../../../../hooks/useFetchModels';
+import {runOrchestration, runSingleCall} from '../utils/aiOrchestration';
+import {assertIsSerializedInput, getExpectedOutputType, parseFormat, serializeInput} from '../utils/formatUtils';
 
 
 export interface UseAIProcessorOptions {
     onSuccess?: (result: any) => void;
     onError?: (error: string) => void;
 }
 
-function getExpectedOutputType (format: any): string {
-    try {
-        const schema = typeof format === "string" ? JSON.parse(format) : format;
-
-        if (!schema || typeof schema !== "object") return "unknown";
-
-        if (schema.type) {
-            return schema.type;
-        }
-
-        for (const key of ["oneOf", "anyOf", "allOf"]) {
-            if (Array.isArray(schema[key])) {
-                for (const subschema of schema[key]) {
-                    const type = getExpectedOutputType(subschema);
-
-                    if (type !== "unknown") return type;
-                }
-            }
-        }
-    } catch (e) {
-        throw new Error(`Invalid format schema: ${e instanceof Error ? e.message : String(e)}`);
-    }
-
-    return "unknown";
-}
-
-const serializeInput = (inputData: any): string | undefined => {
-    if (inputData == undefined) {
-        return undefined;
-    }
-
-    if (typeof inputData === 'string') {
-        return inputData;
-    }
-
-    if (typeof inputData === 'object') {
-        return JSON.stringify(inputData, null, 4);
-    }
-
-    return String(inputData);
-};
-
-function assertIsSerializedInput (input: any): asserts input is string {
-    if (typeof input !== 'string') {
-        throw new Error(`Expected serialized input to be a string, but got ${typeof input}`);
-    }
-}
-
-const buildUnifiedFormat = (format: {onSuccess?: string; onError?: string;}): string | undefined => {
-    if (!format) return undefined;
-
-    const {onSuccess, onError} = format;
-
-    if (onSuccess && onError) {
-        return JSON.stringify({
-            oneOf: [
-                JSON.parse(onSuccess),
-                JSON.parse(onError)
-            ]
-        });
-    }
-
-    if (onSuccess) return onSuccess;
-
-    // in case of only onError provided, we ignore it because we don't want to return an error as a success response
-
-    return undefined;
-};
-
 export function useAIProcessor (options: UseAIProcessorOptions = {}) {
     const {onSuccess, onError} = options;
     const [error, setError] = useState<string[]>([]);
@@ -110,7 +41,8 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
         ragHandler,
         conversationHistory,
         think,
-        temperature
+        temperature,
+        orchestrationMode
     }: Pick<GenericNodeData & LlmProcessNodeData, 'input' | 'prompt' | 'message' | 'model' | 'format'> & {
     tools?: {
         schema: ToolSchema,
@@ -126,6 +58,7 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
     };
     think?: boolean;
     temperature?: number;
+    orchestrationMode?: boolean;
 }) => {
         if (!model) {
             const errorMsg = "Please select a model first.";
@@ -136,6 +69,32 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
             return null;
         }
 
+        if (orchestrationMode && (Array.isArray(input) || typeof input === "string")) {
+            setError([]);
+
+            const orchestrationResult = await runOrchestration({
+                input,
+                prompt,
+                model,
+                format,
+                tools,
+                maxToolRetries,
+                think,
+                temperature,
+            });
+
+            if (!orchestrationResult.success) {
+                setError(prev => [...prev, orchestrationResult.error]);
+                onError?.(orchestrationResult.error);
+
+                return null;
+            }
+
+            onSuccess?.(orchestrationResult.result);
+
+            return orchestrationResult.result;
+        }
+
         if (!prompt && !message && !input) {
             const errorMsg = "Please provide a prompt, message, or input data.";
 
@@ -166,7 +125,7 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
                     assertIsSerializedInput(serializedInput);
 
                     const baseUserContent = message
-                        ? `${message.preffix || ''}${serializedInput}${message.suffix || ''}`
+                        ? `${message.prefix || ''}${serializedInput}${message.suffix || ''}`
                         : serializedInput;
 
                     let userContent = baseUserContent;
@@ -217,7 +176,7 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
                         assertIsSerializedInput(serializedInput);
 
                         const userContent = message
-                            ? `${message.preffix || ''}${serializedInput}${message.suffix || ''}`
+                            ? `${message.prefix || ''}${serializedInput}${message.suffix || ''}`
                             : serializedInput;
 
                         messages.push({
@@ -228,42 +187,21 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
                 }
             }
 
-            let parsedFormat;
-            let onErrorSchema;
+            let parsedFormat: object | undefined;
             let onErrorValidator: ((data: any) => boolean) | undefined;
 
-            if (format) {
-                try {
-                    let unifiedFormat: string | undefined;
-
-                    if (typeof format === "object" && (format.onSuccess || format.onError)) {
-                        unifiedFormat = buildUnifiedFormat(format);
-
-                        if (format.onError) {
-                            onErrorSchema = JSON.parse(format.onError);
-
-                            const ajv = new Ajv();
-
-                            onErrorValidator = ajv.compile(onErrorSchema);
-                        }
-                    } else if (typeof format === "string") {
-                        unifiedFormat = format;
-                    }
-
-                    if (unifiedFormat) {
-                        parsedFormat = JSON.parse(unifiedFormat);
-                    }
-                } catch (parseError) {
-                    const errorMsg = `Invalid format JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`;
+            try {
+                ({parsedFormat, onErrorValidator} = parseFormat(format));
+            } catch (parseError) {
+                const errorMsg = `Invalid format JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`;
 
-                    setError(prev => [...prev, errorMsg]);
-                    onError?.(errorMsg);
+                setError(prev => [...prev, errorMsg]);
+                onError?.(errorMsg);
 
-                    return null;
-                }
+                return null;
             }
 
-            const response = await OllamaService.getInstance().fetchAIResponse({
+            const response = await runSingleCall({
                 messages,
                 model,
                 ...(parsedFormat ? {format: parsedFormat} : {}),
@@ -293,10 +231,10 @@ export function useAIProcessor (options: UseAIProcessorOptions = {}) {
             try {
                 const expectedOutputType = getExpectedOutputType(parsedFormat);
 
-                if (expectedOutputType === "object") {
+                if (expectedOutputType === "object" || expectedOutputType === "array") {
                     result = JSON.parse(result);
 
-                    if (onErrorValidator && onErrorValidator(result)) {
+                    if (expectedOutputType === "object" && onErrorValidator && onErrorValidator(result)) {
                         const errorMsg = `LLM returned an error response matching onError schema:\n${JSON.stringify(result, null, 4)}`;
 
                         setError(prev => [...prev, errorMsg]);

client/src/components/nodes/LlmProcessNode/types/workflow.ts

@@ -4,6 +4,8 @@
  *    See the LICENSE file in the project root for license details.     *
  ************************************************************************/
 
+/* eslint-disable max-len */
+
 import type {BaseNodeData} from "../../../../types/workflow";
 import type {Node} from '@xyflow/react';
 import type {NODE_TYPE} from "../constants";
@@ -19,7 +21,7 @@ export const LlmProcessNodeDataSchema = z.object({
         onError: z.string().optional().describe("JSON Schema string for Ollama structured output on error — constrains the LLM reply shape when the node is handling an error"),
     }).optional().describe("Structured output schemas passed to Ollama to constrain LLM response format"),
     message: z.object({
-        preffix: z.string().optional().describe("Text prepended to the user message before sending to the LLM"),
+        prefix: z.string().optional().describe("Text prepended to the user message before sending to the LLM"),
         suffix: z.string().optional().describe("Text appended to the user message before sending to the LLM"),
     }).optional().describe("Message wrapper applied around the incoming data"),
     maxFeedbackLoops: z.number().int().nonnegative().describe("Maximum number of feedback iterations before stopping"),
@@ -31,6 +33,7 @@ export const LlmProcessNodeDataSchema = z.object({
     think: z.boolean().optional().describe("Enable thinking mode for supported models (e.g. deepseek-r1)"),
     temperatureEnabled: z.boolean().optional().describe("Whether to override the default model temperature"),
     temperature: z.number().min(0).max(2).optional().default(0.8).describe("Sampling temperature (0 = deterministic, 2 = very random)"),
+    orchestrationMode: z.boolean().optional().describe("When enabled, an AI orchestrator decomposes the input (string or array) into individual agent tasks, runs them sequentially, then synthesizes a final aggregated response"),
 });
 
 export type LlmProcessNodeData = z.infer<typeof LlmProcessNodeDataSchema>;
@@ -52,4 +55,5 @@ export const defaultLlmProcessNodeData: LlmProcessNodeData = {
     think: false,
     temperatureEnabled: false,
     temperature: 0.8,
+    orchestrationMode: false,
 }

client/src/components/nodes/LlmProcessNode/utils/aiOrchestration/index.ts

@@ -0,0 +1,11 @@
+/************************************************************************
+ *    Copyright (C) 2025 Code Forge Temple                              *
+ *    This file is part of agentic-signal project                       *
+ *    See the LICENSE file in the project root for license details.     *
+ ************************************************************************/
+
+export * from "./types";
+
+export {runSingleCall} from "./runSingleCall";
+
+export {runOrchestration} from "./runOrchestration";

client/src/components/nodes/LlmProcessNode/utils/aiOrchestration/messageBuilders.ts

@@ -0,0 +1,45 @@
+/************************************************************************
+ *    Copyright (C) 2025 Code Forge Temple                              *
+ *    This file is part of agentic-signal project                       *
+ *    See the LICENSE file in the project root for license details.     *
+ ************************************************************************/
+
+import {AgentTask, AgentTaskResult} from "./types";
+
+/**
+ * Builds a context block injected into an agent's prompt when it depends on prior task outputs.
+ * Only backward references (index < taskIndex) are accepted; forward/invalid refs are warned and skipped.
+ */
+export function buildDependencyContext (
+    task: AgentTask,
+    taskIndex: number,
+    completedResults: AgentTaskResult[]
+): string {
+    if (!task.dependsOn || task.dependsOn.length === 0) return "";
+
+    const invalid = task.dependsOn.filter(i => i < 0 || i >= taskIndex);
+
+    if (invalid.length > 0) {
+        console.warn(
+            `[AI Orchestration] Task ${taskIndex + 1} has invalid dependsOn indices (must be < ${taskIndex}, ignored): ${invalid.join(", ")}`
+        );
+    }
+
+    const validIndices = task.dependsOn.filter(i => i >= 0 && i < taskIndex);
+
+    if (validIndices.length === 0) return "";
+
+    const sections = validIndices.map(i =>
+        `### Output of Task ${i + 1}\n${completedResults[i].response}`
+    );
+
+    return `[CONTEXT FROM PRIOR TASKS]\n${sections.join("\n\n")}\n\n[YOUR TASK]\n`;
+}
+
+export function buildAggregationMessage (results: AgentTaskResult[]): string {
+    const sections = results.map((r, i) =>
+        `## Task ${i + 1}\n**Request:** ${r.task.content}\n**Response:** ${r.response}`
+    );
+
+    return `The following are the results of individual agent tasks. Synthesize them into a final comprehensive response.\n\n${sections.join("\n\n")}`;
+}