@aurelo_npm/sdk 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -95,8 +95,13 @@ export interface AureloToolResultRequest {
     requestId?: string;
     callId?: string;
     toolCallId?: string;
-    previousResponseId?: string;
-    previous_response_id?: string;
+    tool_call_id?: string;
+    toolCall?: {
+        call_id?: string;
+        callId?: string;
+        id?: string;
+        [key: string]: unknown;
+    };
     model?: string;
     publicModel?: string;
     stream?: boolean;
@@ -152,6 +157,9 @@ export declare class AureloSDK {
     private clientIdValue;
     private sessionValue;
     private reconnectCursors;
+    private readonly observedStreamResponses;
+    private readonly observedSseComments;
+    private observedSseCommentOrder;
     constructor(options: AureloSDKOptions);
     getClientId(): Promise<string>;
     getFullClientId(): Promise<string>;
@@ -164,6 +172,7 @@ export declare class AureloSDK {
     private setReconnectCursor;
     private clearReconnectCursor;
     observeSseComment(comment: string): Promise<void>;
+    private rememberSseComment;
     queueMessage(request: string | AureloQueueMessageRequest): Promise<unknown>;
     createResponse(request: AureloResponseRequest, options?: {
         signal?: AbortSignal;
@@ -181,6 +190,9 @@ export declare class AureloSDK {
     reconnect(request?: AureloReconnectRequest): Promise<Response>;
     submitToolResult(request: AureloToolResultRequest): Promise<Response | unknown>;
     streamToolResult(request: AureloToolResultRequest): AsyncGenerator<AureloStreamEvent>;
+    private observeResponseStream;
+    private observeSseTextFragment;
+    private observeSseCommentLine;
     private handleSseLine;
     private readErrorPayload;
     private readResponsePayload;

package/dist/index.js

@@ -291,6 +291,9 @@ export class AureloSDK {
     clientIdValue = null;
     sessionValue = null;
     reconnectCursors = new Map();
+    observedStreamResponses = new WeakSet();
+    observedSseComments = new Set();
+    observedSseCommentOrder = [];
     constructor(options) {
         if (!options.apiKey || !String(options.apiKey).trim()) {
             throw new Error('AureloSDK requires apiKey.');
@@ -423,6 +426,9 @@ export class AureloSDK {
         if (!normalizedComment) {
             return;
         }
+        if (this.rememberSseComment(normalizedComment)) {
+            return;
+        }
         const reconnectCursor = parseReconnectCursorComment(normalizedComment);
         if (reconnectCursor) {
             await this.setReconnectCursor(reconnectCursor.sessionId, reconnectCursor.cursor);
@@ -432,6 +438,20 @@ export class AureloSDK {
             await this.rotateSession(reason);
         }
     }
+    rememberSseComment(comment) {
+        if (this.observedSseComments.has(comment)) {
+            return true;
+        }
+        this.observedSseComments.add(comment);
+        this.observedSseCommentOrder.push(comment);
+        while (this.observedSseCommentOrder.length > 500) {
+            const oldest = this.observedSseCommentOrder.shift();
+            if (oldest) {
+                this.observedSseComments.delete(oldest);
+            }
+        }
+        return false;
+    }
     async queueMessage(request) {
         const session = await this.getSession();
         const queueRequest = typeof request === 'string'
@@ -522,7 +542,7 @@ export class AureloSDK {
             };
             await this.storage.set(SESSION_KEY, JSON.stringify(this.sessionValue));
         }
-        return response;
+        return this.observeResponseStream(response);
     }
     async createResponseWithRotationRetry(request, options = {}) {
         try {
@@ -614,6 +634,7 @@ export class AureloSDK {
             await this.closeSession('request_closed');
             return;
         }
+        const observeComments = !this.observedStreamResponses.has(response);
         const reader = response.body.getReader();
         const decoder = new TextDecoder();
         let buffer = '';
@@ -627,7 +648,7 @@ export class AureloSDK {
                 const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
                 for (const line of lines) {
-                    const event = await this.handleSseLine(line);
+                    const event = await this.handleSseLine(line, { observeComments });
                     if (event) {
                         yield event;
                     }
@@ -635,7 +656,7 @@ export class AureloSDK {
             }
             buffer += decoder.decode();
             if (buffer.trim()) {
-                const event = await this.handleSseLine(buffer);
+                const event = await this.handleSseLine(buffer, { observeComments });
                 if (event) {
                     yield event;
                 }
@@ -700,13 +721,19 @@ export class AureloSDK {
                 payload,
             });
         }
-        return response;
+        return this.observeResponseStream(response);
     }
     async submitToolResult(request) {
         const session = request.sessionId
             ? { ...(await this.getSession()), sessionId: request.sessionId }
             : await this.getSession();
-        const callId = String(request.callId || request.toolCallId || '').trim();
+        const callId = String(request.callId ||
+            request.toolCallId ||
+            request.tool_call_id ||
+            request.toolCall?.call_id ||
+            request.toolCall?.callId ||
+            request.toolCall?.id ||
+            '').trim();
         if (!callId) {
             throw new Error('AureloSDK submitToolResult requires callId.');
         }
@@ -717,10 +744,8 @@ export class AureloSDK {
             requestId: request.requestId || session.requestId,
             sessionId: session.sessionId,
             callId,
-            previousResponseId: request.previousResponseId || request.previous_response_id,
             model: request.model || request.publicModel,
         };
-        const previousResponseId = request.previousResponseId || request.previous_response_id;
         const response = await this.fetchImpl(`${this.baseUrl}/v1/responses`, {
             method: 'POST',
             headers: {
@@ -730,8 +755,6 @@ export class AureloSDK {
             body: JSON.stringify({
                 model: request.model || request.publicModel,
                 publicModel: request.publicModel || request.model,
-                previousResponseId,
-                previous_response_id: previousResponseId,
                 stream: request.stream !== false,
                 sessionId: session.sessionId,
                 requestId: request.requestId || session.requestId,
@@ -760,7 +783,7 @@ export class AureloSDK {
         }
         const contentType = response.headers.get('content-type') || '';
         if (contentType.includes('text/event-stream')) {
-            return response;
+            return this.observeResponseStream(response);
         }
         return this.readResponsePayload(response);
     }
@@ -772,14 +795,88 @@ export class AureloSDK {
         }
         yield { type: 'event', raw: '', data: result };
     }
-    async handleSseLine(line) {
+    observeResponseStream(response) {
+        const contentType = response.headers.get('content-type') || '';
+        if (!response.body || !contentType.includes('text/event-stream') || typeof ReadableStream === 'undefined') {
+            return response;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        const body = new ReadableStream({
+            start: async (controller) => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
+                        }
+                        if (value) {
+                            buffer = await this.observeSseTextFragment(decoder.decode(value, { stream: true }), buffer);
+                            controller.enqueue(value);
+                        }
+                    }
+                    const trailing = decoder.decode();
+                    if (trailing) {
+                        buffer = await this.observeSseTextFragment(trailing, buffer);
+                    }
+                    if (buffer.trim()) {
+                        await this.observeSseCommentLine(buffer);
+                    }
+                    controller.close();
+                }
+                catch (error) {
+                    controller.error(error);
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            },
+            cancel: async (reason) => {
+                try {
+                    await reader.cancel(reason);
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            },
+        });
+        const observedResponse = new Response(body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+        this.observedStreamResponses.add(observedResponse);
+        return observedResponse;
+    }
+    async observeSseTextFragment(fragment, previousBuffer) {
+        if (!fragment) {
+            return previousBuffer;
+        }
+        const lines = `${previousBuffer}${fragment}`.split(/\r?\n/);
+        const buffer = lines.pop() || '';
+        for (const line of lines) {
+            await this.observeSseCommentLine(line);
+        }
+        return buffer;
+    }
+    async observeSseCommentLine(line) {
+        const trimmed = String(line || '').trim();
+        if (!trimmed.startsWith(':')) {
+            return;
+        }
+        await this.observeSseComment(trimmed.slice(1).trim());
+    }
+    async handleSseLine(line, options = {}) {
         const trimmed = line.trim();
         if (!trimmed) {
             return null;
         }
         if (trimmed.startsWith(':')) {
             const comment = trimmed.slice(1).trim();
-            await this.observeSseComment(comment);
+            if (options.observeComments !== false) {
+                await this.observeSseComment(comment);
+            }
             return { type: 'comment', raw: line, comment };
         }
         if (trimmed === 'data: [DONE]') {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@aurelo_npm/sdk",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Aurelo API-key SDK with stable client identity and backend-driven session rotation.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
     "dist/index.js",
-    "dist/index.d.ts"
+    "dist/index.d.ts",
+    "!README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",