DEV Community: Ahmad Abdulaziz

Resolving "This workflow run was not suspended" in Nested Mastra Workflows

Ahmad Abdulaziz — Wed, 31 Dec 2025 14:15:40 +0000

If you are building nested workflows with Mastra and encountering the error "This workflow run was not suspended," it is likely because you are attempting to resume the child workflow directly instead of through the parent.

The Problem

When a nested workflow hits a suspension point like a manual trigger or user input step, the entire execution state is tied to the main parent workflow.

//mainworkflow.ts
export const mainWorkflow = createWorkflow({
  id: "benki",
})
  .then(childWorkflow).commit();

//childworkflow.ts

//nested workflow
export const childWorkflow = createWorkflow({
  id: "child-workflow",
  description: "Workflow for processing transfers",
  inputSchema: z.object({
    message: z.string(),
  }),
  outputSchema: z.object({
    message: z.string(),
  })
})
  .then(resolveStep)
  .then(requestInfoFormUserStep) //suspend step to get info from the user
  .then(finalExecutionStep)
  .commit();

// app.ts
import { mastra } from "../mastra";

const workflow = mastra.getWorkflow("mainWorkflow");
const workflowRun = await workflow.createRun();

In the example below, even though the suspension happens inside childWorkflow, attempting to resume it using mastra.getWorkflow("childWorkflow") will fail because that specific run context doesn't exist independently of the parent.

const resumeWorkflow = mastra.getWorkflow("childWorkflow");
const workflowRun = await resumeWorkflow.createRun({ runId });


// Resume the workflow from the suspended step
await workflowRun.resume({
  step: ["child-workflow", "request-data"],
  resumeData: { /* ... */ },
});

The Solution

You must access the main workflow that initiated the run. The step property in the resume object should then use an array representing the suspendedPaths to point to the correct step inside the nested workflow.

const resumeWorkflow = mastra.getWorkflow("mainWorkflow"); //main workflow
const workflowRun = await resumeWorkflow.createRun({ runId });

await workflowRun.resume({
  step: ["child-workflow", "request-data"],
  resumeData: { /* ... */ },
});

Note: Ensure the strings in your step array exactly match the id fields defined in your workflow configuration.

OSI model for Software Engineers

Ahmad Abdulaziz — Fri, 30 Apr 2021 07:24:02 +0000

Few years ago during my CS degree, I could remember my lecturer explaining the Open Systems Interconnection (OSI model) under networking and could still remember how complex it seems, and I had to memorize everything to pass the exam. I thought I will never need to understand it as a software engineer. Fast-forward to some months ago trying to understand how load balancing works in layer 7 and layer 4, I had to restudy the OSI model again, this time around not as a student but as a software engineer. I had to relearn what I thought I never needed to learn.

What is OSI model?

OSI model is an initial for Open System Interconnection, and it standardized the communication in the computer system. It is what the internet, mobile, LAN, and router uses to establish communication. In a simple term, it is how data is passed from system A to system B either with LAN or Wi-Fi.

The OSI model consists of 7 different layers and each layer contains a different protocol. The layers are the Application layer, Presentation layer, Session layer, Transport layer, Network layer, Data-Link layer, and the Physical layer. Let's explain how data moves from the topmost layer to the last layer.

Application Layer (Layer 7): This is where System A (the client) makes a request to System B. So let's say System A sent a GET/POST request to System B, this request contains a bunch of information, such as headers, cookies, content-type, body, etc., which is summed up into a string, passed to the rest of the OSI models as byte data. This layer also consists of other protocols like HTTP, FTP, TELNET, and SMTP.

Presentation Layer (Layer 6): This layer might be optional if you are using HTTPS as data sent through HTTPS is already encrypted. The presentation layer encrypts data coming from the application layer. This layer transforms the data(string) into byte and also compresses the data before sending it to the next layer and uses the SSL for encryption and decryption.

Session Layer (Layer 5): Session Layer is simple as it's just appending a session to the data coming from the presentation layer. This layer checks the authentication and authorization of the user/data being sent.

Transport Layer (Layer 4): This breakdown the data into a sequential, manageable segment, and each segment is attached to the source and destination port. It also controls the amount of data being transmitted and uses Automatic Repeat Request to retransmit data in case of any error. The transport layer uses UDP(User Datagram Protocol) and TCP (Transmission Control Protocol).

Network Layer (Layer 3): After receiving the segment from the transport layer, the network layer attaches both destination and source IP Address to form packets. This layer also determines the best path for data delivery from source to the determination.

Data Link Layer (Layer 2): Breaks down the packets received from the network layer and the mac address of both the sender and receiver are appended to the packet to form frames.

Physical Layer (Layer 1): On the physical layer, the frames received from the data link layer are converted into 0's and 1's (of course that's what the system understands) i.e. bits that are converted into signals.

NOTE: This is not in any way a comprehensive detail of the OSI model especially from a networking perspective. This is a brief breakdown to help you understand how systems communicate and send data to each other through the OSI model.

Using Fetch API to Get and Post

Ahmad Abdulaziz — Thu, 14 Jun 2018 15:48:40 +0000

In this article, I will talk about how to use javascript fetch API to get and post data to a public API.

PREREQUISITE

Text Editor (Notepad++, VSCode, Atom, Bracket, Sublime, any text editor of your choice)
Browser( Chrome, Moxilla)
Any server of your choice (WAMP, XAMP), you can also install live-server extension if you are using VScode, atom-live-server if you are using Atom, or just install npm live server using npm install –g live-server if you have node install on your machine.

INTRO

Fetch API is a built-in Javascript ES6 Promise that is used to make XMLHttpRequest simpler and easier to GET or POST data asynchronously. There are a lot of libraries that are used to make XMLHttpRequest simpler and easier to read. The most popular one is "jquery's ajax", but fetch API allows us to make XMLHttpRequest with Native Javascript without import of any library.

Below is a syntax of simple fetch() call back

#fetch Syntax

         fetch(url)
            .then(function (res) {
                return res, json()
            })
            .then(function (data) {
                Console.log(data);
            }).catch(function (err) {
                console.log(err)
            })

How to use fetch API to GET data from an API

Create a directory, name it any name of your choice, mine will be call fetchAPI. You can do this using the traditional way of creating a directory, create an index.html file inside the folder or you can use the code below in your terminal.

//create directory
       mkdir fecthAPI
//enter the fecthAPI folder
       cd fetchAPI
//create  an index.html file
       touch index.html

Let add the basic html tags, two button tags with an id of id="getData" and id="getAPI" respectively and a paragraph tag with an id='result'.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Fetch API</title>
</head>
<body>
      <button id="getData">GET DATA FROM LOCAL</button>
          <button id="getData">GET DATA FROM API </button>
          <p id="result"></p>

</body>
</html>

The buttons will be used to send a GET request to a local sampleUser.json and public API. There are a lot of public API's you can get data from e.g Github API, Random User API. But in this example, we will be using JSONPlaceholder API. An API that generates random users.

Create javascript eventListener to handle the click event in the index.html file.

<script>
        document.getElementById('getData').addEventListener('click', getData);
        document.getElementById('getAPI').addEventListener('click', getAPI);


        function getData(){
            // code to execte
        }

        function getAPI(){
            // code to execte
        }

</script>

Let get data from the local file using the fetch API to give more understanding on how to work with the local file. Create a JSON demo “sampleUsers.json” to try and get data in it. >Note: Create your sampleUser.json in the same folder with the index.html file for easy access.

[
    {
        "id": 1,
        "name": "Ahmad Abdul-Aziz",
        "email": "Ahmad.abdulaziz37@gmail.com"     
    },
    {
        "id": 2,
        "name": "Ahmad Habib Hussein",
        "email": "Ahmadhabibhussein@mail.com"     
    },
    {
        "id": 3,
        "name": "Abdullahi Aminu",
        "email": "Aminuawesome@mail.com"     
    },
    {
        "id": 4,
        "name": "Idris Muhammad",
        "email": "rismad@mail.com"     
    }
]

Good, now let write the fetch() script to get data from the sampleUser.json file you just created and output the result to the index.html

Note: Write script inside getData() function

//getData function

//Using javascript ES5 function 

fetch('sampleUser.json')
    .then(function (res) {
        return res.json();
    })
    .then(function (data) {
        let result = `<h2> User Info From sampleUser.json </h2>`;
        data.forEach((user) => {
            const { id, name, email } = user
            result +=
            `<div>
                <h5> User ID: ${id} </h5>
                <ul class="w3-ul">
                    <li> User Name : ${name}</li>
                    <li> User Email: ${email} </li>
                </ul>
            </div>`;

            document.getElementById('result').innerHTML = result;
        });
       })

Ok, we are good to go. Run the code. “Yay” Simple and fast right? We will apply the same method to get data from a real API but this time supplying the API endpoint.

Note: Write script inside getAPI() function

//sampleUser.json is replaced by an API endpoint.

//Using ES6 arrow function 

    fetch('https://jsonplaceholder.typicode.com/users')
        .then((res) => { return res.json() })
        .then((data) => {
            let result = `<h2> Random User Info From Jsonplaceholder API</h2>`;
            data.forEach((user) => {
                const { id, name, email, address: { city, street } } = user
                result +=
                    `<div>
                     <h5> User ID: ${id} </h5>
                         <ul class="w3-ul">
                             <li> User Full Name : ${name}</li>
                             <li> User Email : ${email} </li>
                             <li> User Address : ${city}, ${street} </li>
                         </ul>
                      </div>`;
                        document.getElementById('result').innerHTML = result;
                    });
                })

Sweet at this point, we can get data from both sampleUser.json locally and Jsonplaceholder API. Let go on and Post data

How to use fetch API to POST data to an API

In our index.html file let add a form with an id='postData', two input box and a submit button.

<form  id="postData">
        <div>
            <input type="text" name="" id="tittle">
        </div>
        <div>
            <textarea name="" id="body" cols="20" rows="5"></textarea>
        </div>
        <input type="submit" value="SEND POST">
    </form>

Add an eventListener to handle the submit button in our form.

document.getElementById('postData').addEventListener('submit', postData);

 function postData(event){
            event.preventDefault();

            let tittle = document.getElementById('tittle').value;
            let body = document.getElementById('body').value;

            fetch('https://jsonplaceholder.typicode.com/posts', {
                method: 'POST',
                headers : new Headers(),
                body:JSON.stringify({tittle:tittle, body:body})
            }).then((res) => res.json())
            .then((data) =>  console.log(data))
            .catch((err)=>console.log(err))
        }

Use preventDefault() method to stop or prevents the browser from executing the default action. You can handle your response any way you feel like but in this example, we are going to output it to the console.

Conclusion

We have come to the end of this tutorial. Thank you for reading thus far.

This post is just a simple introduction of how to GET and POST data with fetch API. Feel free to explore more:

You can grab the final source code with styling using w3schools CSS
here on my GitHub repo, Repo Link. and DEMO ON. Don't forget to star the repo

If you’d like to learn more please visit. Mozilla fetchAPI.

Follow me on twitter @dev_amaz and feel free to contact me if you need any help. You can also send me email on Ahmad.abdulaziz37@gmail.com.

Let discuss Software License

Ahmad Abdulaziz — Wed, 13 Jun 2018 12:47:37 +0000

Software licensing is one of the important things most developers neglect, especially when cloning, working or building an OSS.

What is Software license
Types
Why you should have one
And Advantages.

What Podcast do you recommend for developer to get better.

Ahmad Abdulaziz — Tue, 28 Nov 2017 20:17:02 +0000

What podcast would you advice developers to checkout to improve, and become better developer.

What the heck is an API?

Ahmad Abdulaziz — Thu, 23 Nov 2017 14:21:08 +0000

Have you come across or heard of this acronym API but don't really know what is it and/or what its used for? I remember the first time I heard about it. It was in a boot camp when I was told to build a web app that can consume API I was like, what the heck is API?
Here in this article we will address the following :-

What is an API
Why API

All set? Ready? Go!

What is API?
API (Application Programming Interface) is a set of subroutine definitions, protocols, and tools for building application software. -wikipedia

Does that sound more confusing, Ok let push aside the fancy development lingo - I mean the “wikipedia standard” and imagine an API being a messenger that accepts requests and delivers messeages. Are you following or should we makes it more interesting?

Imagine API to be Pizza hut (a company that sells pizza and does home delivery) everybody loves pizza 🍕 right? We pick our phone and call Pizza hut to place an order with the type of pizza we want, the quantity we want and the address we want it delivered (i.e sending a request). Pizza hut takes our order and sends a pizza to that address.

Have you ever wondered how Pizza Hut prepares it’s pizza and delivers it on time? how they do it is actually none of our business). And tyhat is basically how API works.

APIs allow software(application) to talk to each other without user intervention. When we place our order with Pizza Hut, we gave them our address how pizza hut delivery guy found the address is not something we must know or worry about and I am sure nobody wants to be bored with that detail.

Why API
Let’s imagine everyone have to go to pizza hut (the pizzeria) to get their pizza, no delivery guy, no waiter, no order arrangement. Can you imagine how time consuming and inconvenient that will be; following long queues and getting stress out.

Instead of going to Pizza Hut ourselves anytime we want pizza, we can make Pizza hut come to us. Pizza hut makes it easier for us by delivering what we want to our convenient address. That is how API make our work easier in development.

Now let say we want to build an app that displays weather report, the region, humidity, temperature, time and date. We can just assign a static data and that will never change but we all know the weather changes every time. So the question is how do we get the data to change? Luckily for us we have a lot of web services (provider of weather report) that we can get these data from without having to mount whether sensors all over the world just to get data for our simple app. We will send a GET request to their server through an API endpoint, just like we place order for pizza from pizza hut. The server respond to our request in a ‘‘JSON’’ format. Just like the pizza delivery guy deliver our pizza.
There’s a lot more we can do with the API, but to keep this simple that’s all we will cover in this article. Thanks for reading.

For more information on API visit How stuff work or Introduction to API by Biodun Chris.