@kddd/artinet-sdk
Version:
TypeScript SDK for the Agent2Agent (A2A) Protocol
100 lines • 4.29 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.handleEventStream = handleEventStream;
exports.executeStreamEvents = executeStreamEvents;
/**
* Event stream utilities for handling Server-Sent Events (SSE).
*/
const parser_js_1 = require("../rpc/parser.js");
const eventsource_parser_1 = require("eventsource-parser");
const rpc_client_js_1 = require("../rpc/rpc-client.js");
const log_js_1 = require("../../utils/logging/log.js");
/**
* Creates an async generator for processing task events from an SSE stream
*
* @template T The type of task event to process (TaskStatusUpdateEvent or TaskArtifactUpdateEvent)
* @param response The fetch Response object containing the event stream
* @returns An async generator yielding the specified type of task events from StreamingResponse
*/
async function* handleEventStream(response) {
if (!response.ok || !response.body) {
let errorText = null;
try {
errorText = await response.text();
}
catch (_) { }
(0, log_js_1.logError)("handleEventStream", `HTTP error [${response.status}:${response.statusText}] - ${errorText}`, new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`));
throw new Error(`HTTP error [${response.status}:${response.statusText}] - ${errorText}`);
}
// Use eventsource-parser to process the SSE stream
const reader = response.body.getReader();
const decoder = new TextDecoder();
const events = [];
const parser = (0, eventsource_parser_1.createParser)({
onEvent: (event) => {
if (event.data) {
if (event.event === "close") {
(0, log_js_1.logDebug)("handleEventStream", "Stream closed");
return;
}
try {
const parsedData = (0, parser_js_1.parseResponse)(event.data);
const eventResult = parsedData.result;
if (eventResult) {
events.push(eventResult);
}
else {
(0, log_js_1.logWarn)("handleEventStream", "Failed to parse SSE data", parsedData);
}
// if (parsedData.final && parsedData.final === true) {
// logDebug("handleEventStream", "Stream completed");
// return;
// }
}
catch (e) {
(0, log_js_1.logWarn)("handleEventStream", "Failed to parse SSE data", e);
}
}
},
onError: (error) => {
(0, log_js_1.logError)("handleEventStream", "Error parsing SSE data", error);
},
onRetry: (retry) => {
(0, log_js_1.logWarn)("handleEventStream", "Retrying SSE connection", retry);
},
});
try {
while (true) {
const { done, value } = await reader.read();
if (done)
break;
const chunk = decoder.decode(value, { stream: true });
parser.feed(chunk);
while (events.length > 0) {
yield events.shift();
}
}
}
finally {
reader.releaseLock();
}
}
/**
* Executes a streaming JSON-RPC request and yields events as they arrive
*
* @template Req The type of request being made
* @template StreamRes The type of streaming response expected
* @param baseUrl The base URL for the API
* @param method The JSON-RPC method to call
* @param params The parameters for the method
* @param customHeaders Any custom headers to include in the request
* @returns An AsyncIterable yielding events from the stream
*/
async function* executeStreamEvents(baseUrl, method, params, customHeaders) {
(0, log_js_1.logDebug)("executeStreamEvents", `Sending streaming request to: ${baseUrl.toString()}, method: ${method}`);
const responsePromise = (0, rpc_client_js_1.sendJsonRpcRequest)(baseUrl, method, params, customHeaders, "text/event-stream");
const response = await responsePromise;
(0, log_js_1.logDebug)("executeStreamEvents", "Response", response);
yield* handleEventStream(response);
}
//# sourceMappingURL=event-stream.js.map