DEV Community: PurityGwaro

Building an A2A Agent for telex.im using Mastra

PurityGwaro — Mon, 03 Nov 2025 11:57:45 +0000

The Challenge

For my HNGi13 Stage 3 backend task, I needed to create an Agent-to-Agent (A2A) integration with Telex.IM using JavaScript/TypeScript. I had to use Mastra AI which was both exciting and a bit challenging since I was new to building AI agents.
I built a book suggestion agent that suggested 5 books to a user depending on the topic they submit.

Getting Started

Learning the Ropes with Mastra AI

I began by setting up a Mastra project, which came with a weather agent example. This was super helpful because it showed me how everything fits together. The example covered:

How to set up an agent
Adding tools and workflows
Handling API requests

Building My Book Suggestion Agent

Using the weather agent as a guide, I built my book suggestion agent. Here's how it went:

Setting Up: I organized the code and set up TypeScript to catch my mistakes early.
The Book Tool: Created a tool that fetches book recommendations from Open Library.
Conversation Flow: Made sure the agent could handle different types of requests.
Error Handling: Added friendly messages for when things don't go as planned.

The Tricky Part: Telex.IM Integration

This is where things got challenging. I struggled with:

Connecting my A2A agent to telex from my hosted mastra site
Getting the message format just right - had some issues with the string but I figured it out
making requests was initially slow and also giving results I did not want but with a couple of code fixes and more deploys I managed to make it work.

The HNG team provided a helpful blog post that explained how to connect Mastra with Telex.IM which made things much more easier.

What I Learned

The best part? It worked! Now I can:

Get book recommendations through Telex.IM
See how people interact with my agent
Fix issues when they come up

You can check out the interaction logs here to see it in action.

My Big Takeaways

Examples are gold: The weather agent was my best teacher.
Ask for help: Other interns saved me hours of frustration.
Keep trying: The solution often comes right after you want to give up.
Use what you're given: The HNG team's resources were a lifesaver.

This project was a huge learning experience. I went from knowing nothing about AI agents to building something that actually works. These skills will be super useful in any agent I work on next!

HNG13 Internship Stage 0 BE Task

PurityGwaro — Sun, 19 Oct 2025 22:08:48 +0000

I joined HNG Internship this month.
The stage 0 task involved one displaying their profile details and a random cat fact from a provided external API.
Here is an image to the hosted response I sent:

While creating this simple task I got to relearn a few things to do with cors, error handling, using environment variables and hosting(used railway.com). It was a fun task to do. Looking forward to the next one.

Data Structures and Algorithms: Big O Notation

PurityGwaro — Wed, 16 Aug 2023 11:09:03 +0000

Intro

Big O Notation is a way to formalize fuzzy counting.
It allows us to talk formally about how the runtime of an algorithm grows as the inputs grow.
It is used to analyze the performance of an algorithm.

A good performing algorithm is:

faster
occupies less memory during its operation
is readable

In Big O we majorly concentrate on:

Time Complexity
Space Complexity

Time Complexity

This is the number of operations the computer has to perform during the execution of an algorithm. This remains constant no matter what computer we are on.

function addUpTo(n){
    return n * (n + 1) / 2;
}

The above function has 3 operations: *, +, and / whether the input is 1 or 1000000.

function addUpTo(n) {
    let total = 0;
    for(let i = 1; i <= n; i++){
        total +=1;
    }
    return total;
}

This second function on the other hand has these operations from the first to the last if you consider n to be 3:
(total = 0), (let i = 1), <=n(i <= n) three times, +(i++) three times, +=(total +=1) three times.
Now consider an input like n = 1000, those will be 1000 times more operations in the for loop.

Given the examples above, the way Big O Notation is represented for the scenarios is as follows:

constant operations: O(1) - no. of operations remains the same despite the input value
inconsistent no. of operations: O(n) - no. of operations increases as the input value increases
for a for loop inside another for loop: O(n * n)

Space Complexity

The space that an algorithm takes up as the size of the input increases.

When we talk about space complexity we mostly refer to Auxiliary Space Complexity which refers to the space required by the algorithm, not including space taken up by the inputs.

Rules of Thumb

Most primitives(boolean, numbers, undefined, null) are constant space.
Strings require O(n) space (where n is the string length)
Reference types are generally O(n), where n is the length (for arrays) or the number of keys (for objects)

Example 1:

function addUpTo(n) {
    let total = 0;
    for(let i = 1; i <= n; i++){
        total +=1;
    }
    return total;
}

Here we have two variables taking up space while the algorithm executes: total and i. Regardless of the size of the input there will always be two spaces used hence the function above represents O(1) space complexity.

Example 2:

function double(arr) {
    let newArr = [];
    for(let i = 0; i < arr.length; i++){
        newArr.push(2 * arr[i])
    }
    return newArr;
}

This function on the other hand is O(n) since the array length grows hence more space occupied depending on the items in the input array.

Logarithms

Sometimes Big O expressions involve more complex mathematical expressions i.e logarithms.

A logarithm is the inverse of exponentiation. Just like division and multiplication are a pair, the two are.
The logarithm of a number roughly measures the number of times you can divide that number by 2 before you get a value that's less than or equal to 1.

Importance of Logarithms in Big O

Certain Searching Algorithms have Logarithmic Time Complexity
Efficient Sorting Algorithms involve Logarithms
Recursion sometimes involves Logarithmic Space Complexity

Analyzing Performance of Arrays and Objects in the lense of Big O Notation

Objects

They are unordered key value pairs

They work well when:

You don't need order
You need fast access / insertion and removal

Big O of Objects

Insertion - O(1)
Removal - O(1)
Searching - O(n)
Access - O(1)

Big O of Object Methods

Objects.keys - O(n)
Objects.values - O(n)
Objects.entries - O(n)
hasOwnProperty - O(1)

Arrays

These are ordered lists

They work well when:

You need order
You need fast access / insertion and removal

Big O of Arrays

Insertion - depends on where we are inserting: end - O(1), beginning - O(n)
Removal - depends on where we are removing: end - O(1), beginning - O(n)
Searching - O(n)
Access - O(1)

Big O of Array Methods

push - O(1)
pop - O(1)
shift - O(n)
unshift - O(n)
concat - O(n)
slice - O(n)
sort - O(n * log n)
for each/map/filter/reduce... - O(n)