How Can I Split a Single AI Agent Output into Four Distinct Fields for Google Tasks?

Below is an explanation of the issue and some suggestions for how you might address it.

---

The Issue

You have a single output from your AI agent that contains all the details for your Google Task:

• Title
• Due Date
• Notes
• Status

Instead of getting these as separate outputs or fields, the agent returns one combined response. As a result, your Google Tasks node doesn’t automatically know how to map each piece of information to the correct field (Title, Due Date, etc.).

---

Why This Happens

When the AI agent returns a single output, it typically is either a single string or one JSON object. Without a clear structure separating each piece of data, n8n doesn’t split the fields automatically.

---

Suggested Solutions

1. Output a Structured JSON Object
   Instead of having the AI return a combined answer, modify the prompt (or instruct the AI) to respond with a structured JSON format. For example, you could ask for a response like:

   JSONCopied
   {
     "title": "Your task title here",
     "dueDate": "2023-10-15",
     "notes": "Additional task details",
     "status": "pending"
   }

   Once the agent returns a JSON object like this, you can easily use a Set node or the built-in fields mapping in the Google Tasks node to extract each key.

2. Use a Function or Set Node to Parse the Output
   If your AI agent is already returning a combined string, you can insert a Code or Set node after the AI step to parse the string. For instance, if the response follows a predictable format, you might use a regular expression or JSON parsing (if it’s almost valid JSON) to break out the individual fields. For example:

   JAVASCRIPTCopied
   // Example: assuming the output is a string like "Title: X; Due Date: Y; Notes: Z; Status: W"
   const response = $json.response;
   const parts = response.split(';').map(part => part.trim());
   const data = {};
   
   parts.forEach(part => {
     const [key, value] = part.split(':').map(item => item.trim());
     if(key && value) {
       // Convert key to lowerCamelCase as needed
       if(key.toLowerCase() === 'title'){
         data.title = value;
       }
       if(key.toLowerCase() === 'due date'){
         data.dueDate = value;
       }
       if(key.toLowerCase() === 'notes'){
         data.notes = value;
       }
       if(key.toLowerCase() === 'status'){
         data.status = value;
       }
     }
   });
   
   return data;

   This example shows how you might manually parse a semicolon-separated string into an object. You can then map each key directly to the corresponding field in the Google Tasks node.

3. Consider Using the Structured Output Parser
   If you’re using AI nodes that support attaching a Structured Output Parser, you can enable the Require Specific Output Format option and attach the parser node. This node is designed to convert the AI response into a structured format that you can then use to map to other nodes.

---

Final Recommendation

Using a structured JSON response from your AI is the most robust approach. By instructing the AI to return a JSON object with clearly defined keys, you directly control the output format and eliminate the need for additional parsing.

For example, customize your system prompt to include:

"Please return the response with the following JSON structure:
{
"title": "Submit task title",
"dueDate": "YYYY-MM-DD",
"notes": "Any notes here",
"status": "pending/completed"
}"

This will give you a well-formed response and simplify passing the individual fields to the Google Task node.

---

By structuring your output, you ensure that each field (Title, Due Date, Notes, and Status) is clearly delineated and can be used directly in the Google Tasks node. If you have any additional questions on configuring this in n8n, let me know!

Below is a few suggestions to ensure each field from your AI agent’s output is routed correctly into the Google Task node.

---

Option 1: Use a Function Node to Split the Output

If your AI agent returns a single JSON object (for example:
{
 "title": "My task",
 "dueDate": "2023-10-31",
 "notes": "Some details",
 "status": "pending"
}), you can add a Function node right after the AI agent that returns separate items – one per field. For instance:

JSCopied
// Assume the single output is available as item.json
const data = item.json;

// Create four output items
return [
  { json: { field: "title", value: data.title } },
  { json: { field: "dueDate", value: data.dueDate } },
  { json: { field: "notes", value: data.notes } },
  { json: { field: "status", value: data.status } },
];

You can then use expressions or map each item accordingly in your Google Task node. In case the node is expecting multiple items, this Function node creates them as separate items.

---

Option 2: Parse and Map Directly with a Set Node

If each field is part of the same output object and the Google Task node supports expressions, you might bypass splitting into separate items and map the fields directly using expressions in the node’s fields. For example, set:

• Title: {{ $json.title }}
• Due Date: {{ $json.dueDate }}
• Notes: {{ $json.notes }}
• Status: {{ $json.status }}

This way, even though the output is a single JSON object, each field in the Google Task node will be populated correctly.

---

Option 3: Reformat the AI Agent’s Response

If possible, adjust your prompt or the output format of your AI agent so that it returns a structured response with a clear separation between each field. For example, you might ask for a JSON structure that the n8n Structured Output Parser node can then use. Keep in mind that sub-nodes (like the one for output parsing) resolve expressions against only the first item if multiple items are provided, so ensure that the structured response is designed for your workflow.

---

Final Thoughts

The choice between these options depends on how your workflow and Google Task node are configured:

• Use a Function node if you need separate items for further processing.
• Use direct field mapping if the Google Task node expects all the data in one item.
• Consider changing the agent’s output format if you want to avoid extra parsing steps.

Each method helps ensure that your Google Task node gets the correct value for each field.

Below is a couple of approaches to resolve the issue:

Use Expressions to Map JSON Properties Directly

If your AI agent returns a single JSON object like this:

JSONCopied
{
  "title": "My Task Title",
  "dueDate": "2023-12-31",
  "notes": "Some details about the task",
  "status": "needsAction"
}

you don’t necessarily need to split it into four separate items. Instead, configure your Google Tasks node to reference each property using expressions. For example:

• Title: {{$json["title"]}}
• Due Date: {{$json["dueDate"]}}
• Notes: {{$json["notes"]}}
• Status: {{$json["status"]}}

This way, each field in the Google Tasks node is populated from the corresponding property in the JSON output.

Split the JSON Into Separate Items

If your use case demands that each piece of information be on a separate item (for example, if you need to process or debug them independently), you can do one of the following:

Option 1: Use a Set Node to Restructure Output

1. Add a Set node right after your AI agent (or Structured Output Parser).
2. In the Set node, create new fields or items for each property. You might, for instance, create an array for further processing.

For example, you could set a field called "fields" containing an array of objects:

JSONCopied
[
  { "field": "title", "value": "={{ $json.title }}" },
  { "field": "dueDate", "value": "={{ $json.dueDate }}" },
  { "field": "notes", "value": "={{ $json.notes }}" },
  { "field": "status", "value": "={{ $json.status }}" }
]

Then, use an Item Lists or SplitInBatches node to process each array element as an individual item, mapping these items to the Google Tasks node configuration if needed.

Option 2: Use a Code Node

If you’re comfortable with JavaScript, add a Code node which takes in your single JSON object and returns multiple items. For example:

JSCopied
const output = [];
const data = $json; // the JSON object from the previous node

output.push({ json: { field: "title", value: data.title } });
output.push({ json: { field: "dueDate", value: data.dueDate } });
output.push({ json: { field: "notes", value: data.notes } });
output.push({ json: { field: "status", value: data.status } });

return output;

This script converts one item into an array of four distinct items. You can then route each item separately in your workflow if needed.

Recommendation

For most cases—especially when passing data directly to the Google Tasks node—it’s simplest to use expressions to extract each field value rather than splitting your output into multiple items. This minimizes the number of nodes and keeps your workflow clear.

Choose the method that best fits your workflow’s requirements!