Beyond the Gateway: Direct BIP Report Integration in AI Agent Studio

Vajeedunnisa Mohammad — Mon, 18 May 2026 16:08:02 GMT

If there is one thing I absolutely love, it’s tackling new things head-on.

In the enterprise automation space, it’s incredibly easy to fall into the trap of doing things “the way they’ve always been done.” For a long time, if you wanted to pull an Oracle BI Publisher (BIP) report inside your automation flows, the default reflex has been to route everything through Oracle Integration Cloud (OIC). OIC is fantastic — it’s powerful, reliable, and a staple for complex architecture.

But I love asking: What else is possible? Can we add another tool to our toolkit?

Instead of routing every single report through an integration layer, we have an alternative route. We can call BIP reports directly via an external REST call right inside AI Agent Studio!

Depending on how you like to architect your agents, you can implement this in two distinct ways: a hands-off Supervisor Flow or a structured, step-by-step Workflow.

Let’s try it out! 🛠️

The Core Ingredient: The External REST Tool

Before building either flow, we need to create an External REST Tool in your Agent Studio that talks directly to Oracle’s public report service.

Configure the tool to pass your authentication headers and use this SOAP envelope as the request body template. Just make sure to swap out the placeholder path and parameters with your specific report details:

Headers:
Content-Type : application/soap+xml


   
   
      
         
            csv
            
               
                  p_order_number
                  
                     {OrderNumber}
                  
               
            
            /Custom/OIC_Reports/OrderDetails Report.xdo
            -1

Once this tool is ready, you can deploy it using one of two design patterns:

Pattern 1: The Supervisor Flow (No Code)

If you want a lean, intelligent setup where the LLM handles the heavy lifting natively, the Supervisor pattern is perfect. You don’t need any custom JavaScript arrays or manual parsing nodes — the agent’s cognitive capabilities handle it all.

How to set it up:

Attach your newly created External REST Tool directly to your Agent.
Provide the Agent with a clear system prompt instructing it how to manage the inputs and outputs.

The Supervisor Prompt:

You are a helpful assistant with access to the GetOrderData tool, which retrieves order details from an Oracle BI Publisher report.
When a user asks about order details or requests information for a specific order number, follow these steps:
1. Extract the Order number from the user input and Call the GetOrderData tool with user provided order number as input parameter..
2. Parse the CSV response returned by the tool.
4. Present the data in a clean, well-structured markdown table with appropriate column headers.
5. If no data is returned or the order is not found, inform the user clearly.
Always confirm the order number with the user before calling the tool if it is ambiguous or missing.
When displaying results:
- Format all data as a readable markdown table.
- Use the first row of the CSV as the column headers.
- Align columns cleanly.
- If there are many rows, summarize the total count at the end (e.g., "Showing 5 records for Order #100010").

The beauty of this flow is its simplicity. You pass the input parameters and context in the input prompt, and the supervisor handles the tool execution and data formatting seamlessly in one place.

Response:

Pattern 2: The Workflow (Structured Action)

If you prefer explicit control, predictability, and mapping out every exact transition on your canvas, the step-by-step Workflow pattern is the way to go.

How to set it up:

1. Set the Variables

Use a Set Variable node (or an initial LLM node) to capture and store your input parameters (like OrderNumber) from the incoming user request.

2. Call the Tool

Add the External REST tool to your canvas and pass the variables from the previous step into your SOAP template payload.

3. Convert Report Bytes to JSON Object

Because Oracle returns the report data safely wrapped as a Base64 string inside the XML element (and sometimes transitions tags without closing them), we use a targeted, platform-agnostic JavaScript node to convert it.

Pass $context.$nodes.EXTRACTORDERDETAILS.$output into this script to output a clean JSON array:

// 1. Grab the input payload from your node
const xmlResponse = $context.$nodes.EXTRACTORDERDETAILS.$output;

// 2. Extract the Base64 string using Regex
const regex = /([^<]+)/;
const match = xmlResponse ? xmlResponse.match(regex) : null;

let finalResult = "[]"; // Default fallback to empty array string

if (match && match[1]) {
    const base64Data = match[1].trim();

    // 3. Decode the Base64 data
    let decodedCsv = "";
    if (typeof atob === 'function') {
        decodedCsv = atob(base64Data);
    } else if (typeof Buffer !== 'undefined') {
        decodedCsv = Buffer.from(base64Data, 'base64').toString('utf8');
    }

    // 4. Convert CSV lines into a structured JSON array
    if (decodedCsv) {
        // Split text by lines and remove empty rows
        const lines = decodedCsv.split('\n').map(line => line.trim()).filter(line => line);
        
        if (lines.length > 1) {
            // First line contains the headers: ["ORDER_NUMBER", "HEADER_ID"]
            const headers = lines[0].split(',');
            const jsonArray = [];

            // Loop through the data rows
            for (let i = 1; i < lines.length; i++) {
                const currentLine = lines[i].split(',');
                const rowObject = {};
                
                headers.forEach((header, index) => {
                    rowObject[header] = currentLine[index] || null;
                });
                
                jsonArray.push(rowObject);
            }
            
            // Turn the array into a readable JSON string
            finalResult = JSON.stringify(jsonArray, null, 2);
        }
    }
} else {
    finalResult = JSON.stringify({ error: "Could not locate  data" });
}

4. Displaying a Clean Table Format

Now that we have structured JSON data sitting in {{$context.$nodes.REPPORTBYTESTOJSON.$output.result}}, we don’t want to just dump raw JSON text on our end users.

Pass that JSON output directly into a final LLM Node with this formatting prompt to render a polished, bordered UI element instantly:

Prompt:

convert the following JSON object into a clean, professional HTML table. Json: {{$context.$nodes.REPPORTBYTESTOJSON.$output.result}} 
- Always use HTML markup while displaying data in table. Never markdown.
- Use Inline CSS only (no

Stories by Vajeedunnisa Mohammad on Medium

Beyond the Gateway: Direct BIP Report Integration in AI Agent Studio