context.http

The context.http object provides an HTTP client for making outbound requests from your mim. All requests are asynchronous and use callback functions for handling responses.

request()

Makes an HTTP request to an external URL.

context.http.request(options)

Parameters

Parameter	Type	Required	Description
options	object	Yes	Request configuration object

Options

Option	Type	Default	Description
url	string	:	Target URL (required)
type	string	"GET"	HTTP method: "GET", "POST", "PUT", "DELETE", etc.
data	string | object	:	Request body; objects are automatically JSON-encoded
headers	object	{}	HTTP headers as key-value pairs
authorization	string	:	Authorization header value (e.g., "Bearer token123")
connectionTimeout	number	:	Connection timeout in milliseconds
socketTimeout	number	:	Socket timeout in milliseconds
outputFile	string	:	Path to save response body to a file
success	function	:	Callback invoked on successful response
error	function	:	Callback invoked on error

Success Callback

success: (result) => {
    result.data     // Response body content (string)
    result.headers  // Response headers (object)
    result.status   // HTTP status code (number)
}

Error Callback

error: (error) => {
    error.message  // Error message (string)
    error.status   // HTTP status code, if HTTP error (number)
    error.content  // Response body, if HTTP error (string)
    error.headers  // Response headers, if HTTP error (object)
}

---

Examples

Simple GET Request

app.get('/users', (request, response) => {
    context.http.request({
        url: 'https://api.example.com/users',
        success: (result) => {
            var users = JSON.parse(result.data);
            response.end(JSON.stringify(users));
        },
        error: (err) => {
            response.statusCode = 500;
            response.end(err.message);
        }
    });
});

GET with Headers

app.get('/protected', (request, response) => {
    context.http.request({
        url: 'https://api.example.com/protected',
        headers: {
            'X-Custom-Header': 'value'
        },
        authorization: 'Bearer ' + context.env.API_TOKEN,
        success: (result) => {
            response.end(result.data);
        },
        error: (err) => {
            response.statusCode = err.status || 500;
            response.end(err.message);
        }
    });
});

POST with JSON Body

app.post('/users', (request, response) => {
    var userData = JSON.parse(request.body);

    context.http.request({
        type: 'POST',
        url: 'https://api.example.com/users',
        headers: {
            'Content-Type': 'application/json'
        },
        data: userData,  // Objects are auto-JSON-encoded
        success: (result) => {
            response.statusCode = 201;
            response.end(result.data);
        },
        error: (err) => {
            response.statusCode = err.status || 500;
            response.end(JSON.stringify({ error: err.message }));
        }
    });
});

PUT Request

app.put('/users/:id', (request, response) => {
    var userId = request.params.id;
    var updates = JSON.parse(request.body);

    context.http.request({
        type: 'PUT',
        url: 'https://api.example.com/users/' + userId,
        headers: {
            'Content-Type': 'application/json'
        },
        authorization: request.authorization,
        data: updates,
        success: (result) => {
            response.end(result.data);
        },
        error: (err) => {
            response.statusCode = err.status || 500;
            response.end(err.message);
        }
    });
});

DELETE Request

app.delete('/users/:id', (request, response) => {
    var userId = request.params.id;

    context.http.request({
        type: 'DELETE',
        url: 'https://api.example.com/users/' + userId,
        authorization: request.authorization,
        success: (result) => {
            response.end(JSON.stringify({ deleted: true }));
        },
        error: (err) => {
            response.statusCode = err.status || 500;
            response.end(err.message);
        }
    });
});

With Timeouts

app.get('/slow-api', (request, response) => {
    context.http.request({
        url: 'https://api.example.com/slow-endpoint',
        connectionTimeout: 5000,  // 5 seconds to connect
        socketTimeout: 30000,     // 30 seconds for response
        success: (result) => {
            response.end(result.data);
        },
        error: (err) => {
            response.statusCode = 504;
            response.end('Request timed out');
        }
    });
});

Download to File

app.get('/download', (request, response) => {
    context.http.request({
        url: 'https://example.com/large-file.zip',
        outputFile: '/data/downloads/file.zip',
        success: (result) => {
            response.end(JSON.stringify({
                saved: true,
                status: result.status
            }));
        },
        error: (err) => {
            response.statusCode = 500;
            response.end(err.message);
        }
    });
});

---

Calling Other mims

You can call other mims running on the same mimOE instance:

app.get('/aggregate', (request, response) => {
    var port = context.info.httpPort;

    context.http.request({
        url: 'http://127.0.0.1:' + port + '/other-mim/v1/data',
        authorization: request.authorization,
        success: (result) => {
            var data = JSON.parse(result.data);
            response.end(JSON.stringify({
                source: 'other-mim',
                data: data
            }));
        },
        error: (err) => {
            response.statusCode = 500;
            response.end(err.message);
        }
    });
});

---

Calling AI Inference

Call the local mILM inference service:

app.post('/chat', (request, response) => {
    var body = JSON.parse(request.body);
    var port = context.info.httpPort;

    context.http.request({
        type: 'POST',
        url: 'http://127.0.0.1:' + port + '/mimik-ai/openai/v1/chat/completions',
        headers: {
            'Content-Type': 'application/json'
        },
        data: {
            model: 'my-model',
            messages: [
                { role: 'user', content: body.prompt }
            ]
        },
        success: (result) => {
            var completion = JSON.parse(result.data);
            response.end(JSON.stringify({
                reply: completion.choices[0].message.content
            }));
        },
        error: (err) => {
            response.statusCode = 500;
            response.end(err.message);
        }
    });
});

---

Error Handling

Always provide an error callback to handle failures gracefully:

app.get('/data', (request, response) => {
    context.http.request({
        url: 'https://api.example.com/data',
        success: (result) => {
            response.end(result.data);
        },
        error: (err) => {
            // Check if it's an HTTP error with status code
            if (err.status) {
                if (err.status === 404) {
                    response.statusCode = 404;
                    response.end('Resource not found');
                } else if (err.status >= 500) {
                    response.statusCode = 502;
                    response.end('Upstream server error');
                } else {
                    response.statusCode = err.status;
                    response.end(err.content || err.message);
                }
            } else {
                // Network or timeout error
                response.statusCode = 503;
                response.end('Service unavailable: ' + err.message);
            }
        }
    });
});

---

Best Practices

Use Environment Variables for Credentials

context.http.request({
    url: context.env.EXTERNAL_API_URL + '/endpoint',
    authorization: 'Bearer ' + context.env.EXTERNAL_API_KEY,
    // ...
});

Set Appropriate Timeouts

context.http.request({
    url: 'https://api.example.com/data',
    connectionTimeout: 5000,   // Fail fast if can't connect
    socketTimeout: 15000,      // Allow time for response
    // ...
});

Validate Responses

success: (result) => {
    try {
        var data = JSON.parse(result.data);
        if (!data.expectedField) {
            response.statusCode = 502;
            response.end('Invalid response from upstream');
            return;
        }
        response.end(JSON.stringify(data));
    } catch (e) {
        response.statusCode = 502;
        response.end('Invalid JSON from upstream');
    }
}

---

Related

• context.storage: Persistent storage API
• context.info: Node metadata and environment
• request: Incoming request object
• response: Response methods