@aurelo_npm/sdk 0.1.0 → 0.1.2

package/dist/index.d.ts

@@ -26,11 +26,48 @@ export interface AureloSession {
     status: 'active' | 'closed' | 'rotation_required';
     rotationReason?: string;
 }
+export interface AureloExposedTool {
+    type?: 'function' | 'mcp' | 'hosted' | 'custom' | 'extension' | 'http' | string;
+    name?: string;
+    description?: string;
+    inputSchema?: Record<string, unknown>;
+    input_schema?: Record<string, unknown>;
+    parameters?: Record<string, unknown>;
+    function?: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+    server_label?: string;
+    server_url?: string;
+    server_description?: string;
+    allowed_tools?: string[];
+    require_approval?: unknown;
+    runtime?: {
+        kind?: 'extension' | 'mcp' | 'http' | 'local' | string;
+        clientId?: string;
+        serverUrl?: string;
+        endpoint?: string;
+        url?: string;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface AureloRequestContext {
+    tools?: unknown[];
+    exposedTools?: AureloExposedTool[];
+    toolStackId?: string;
+    permissionsVersion?: string | number;
+    contextId?: string;
+    contextVersion?: string | number;
+    [key: string]: unknown;
+}
 export interface AureloResponseRequest {
     model: string;
     input?: unknown;
     stream?: boolean;
     metadata?: Record<string, unknown>;
+    context?: AureloRequestContext;
     [key: string]: unknown;
 }
 export interface AureloReconnectRequest {
@@ -38,6 +75,8 @@ export interface AureloReconnectRequest {
     cursor?: string | number;
     model?: string;
     input?: unknown;
+    metadata?: Record<string, unknown>;
+    context?: AureloRequestContext;
     signal?: AbortSignal;
 }
 export interface AureloQueueMessageRequest {
@@ -48,6 +87,25 @@ export interface AureloQueueMessageRequest {
     publicModel?: string;
     model?: string;
     metadata?: Record<string, unknown>;
+    context?: AureloRequestContext;
+    signal?: AbortSignal;
+}
+export interface AureloToolResultRequest {
+    sessionId?: string;
+    requestId?: string;
+    callId?: string;
+    toolCallId?: string;
+    previousResponseId?: string;
+    previous_response_id?: string;
+    model?: string;
+    publicModel?: string;
+    stream?: boolean;
+    context?: AureloRequestContext;
+    tools?: unknown[];
+    output?: unknown;
+    result?: unknown;
+    error?: unknown;
+    metadata?: Record<string, unknown>;
     signal?: AbortSignal;
 }
 export interface AureloStreamEvent {
@@ -121,6 +179,8 @@ export declare class AureloSDK {
     continueResponse(message: string, request?: Omit<AureloQueueMessageRequest, 'message'> & AureloReconnectRequest): AsyncGenerator<AureloStreamEvent>;
     private streamEventsFromResponse;
     reconnect(request?: AureloReconnectRequest): Promise<Response>;
+    submitToolResult(request: AureloToolResultRequest): Promise<Response | unknown>;
+    streamToolResult(request: AureloToolResultRequest): AsyncGenerator<AureloStreamEvent>;
     private handleSseLine;
     private readErrorPayload;
     private readResponsePayload;

package/dist/index.js

@@ -172,6 +172,31 @@ function isTerminalResponseType(type) {
 function isAureloSdkError(value) {
     return value instanceof AureloSDKError;
 }
+function definedEntries(values) {
+    return Object.fromEntries(Object.entries(values).filter(([, value]) => value !== undefined && value !== null && value !== ''));
+}
+function buildContinuationMetadata(request) {
+    const context = request.context || {};
+    return definedEntries({
+        ...(request.metadata || {}),
+        toolStackId: context.toolStackId,
+        permissionsVersion: context.permissionsVersion,
+        contextId: context.contextId,
+        contextVersion: context.contextVersion,
+    });
+}
+function buildContinuationContext(request) {
+    const context = request.context || {};
+    const nextContext = definedEntries({
+        tools: context.tools,
+        exposedTools: context.exposedTools,
+        toolStackId: context.toolStackId,
+        permissionsVersion: context.permissionsVersion,
+        contextId: context.contextId,
+        contextVersion: context.contextVersion,
+    });
+    return Object.keys(nextContext).length ? nextContext : undefined;
+}
 function getPayloadErrorMessage(payload) {
     if (!payload || typeof payload !== 'object') {
         return '';
@@ -273,10 +298,11 @@ export class AureloSDK {
         this.apiKey = String(options.apiKey).trim();
         this.baseUrl = normalizeBaseUrl(options.baseUrl || 'https://aurelo.tech');
         this.queueUrl = String(options.queueUrl || defaultQueueUrl(this.baseUrl)).trim();
-        this.fetchImpl = options.fetch || globalThis.fetch;
-        if (typeof this.fetchImpl !== 'function') {
+        const resolvedFetch = options.fetch || globalThis.fetch;
+        if (typeof resolvedFetch !== 'function') {
             throw new Error('AureloSDK requires fetch. Pass options.fetch in this runtime.');
         }
+        this.fetchImpl = resolvedFetch.bind(globalThis);
         this.storage = options.storage || createDefaultStorage();
         if (options.clientId) {
             this.clientIdValue = normalizeClientId(options.clientId);
@@ -435,6 +461,7 @@ export class AureloSDK {
                 requestId: queueRequest.requestId || session.requestId,
                 publicModel: queueRequest.publicModel || queueRequest.model,
                 metadata,
+                context: queueRequest.context,
             }),
             signal: queueRequest.signal,
         });
@@ -520,16 +547,21 @@ export class AureloSDK {
             return this.createResponseWithRotationRetry(request, options);
         }
         try {
+            const continuationMetadata = buildContinuationMetadata(request);
+            const continuationContext = buildContinuationContext(request);
             await this.queueMessage({
                 message,
                 model: request.model,
                 publicModel: request.model,
-                metadata: request.metadata,
+                metadata: continuationMetadata,
+                context: continuationContext,
                 signal: options.signal,
             });
             return this.reconnect({
                 model: request.model,
                 input: request.input,
+                metadata: continuationMetadata,
+                context: continuationContext,
                 signal: options.signal,
             });
         }
@@ -568,6 +600,7 @@ export class AureloSDK {
                     input: message,
                     stream: true,
                     metadata: request.metadata,
+                    context: request.context,
                 }, { signal: request.signal });
                 yield* this.streamEventsFromResponse(response);
                 return;
@@ -620,6 +653,7 @@ export class AureloSDK {
         const storedCursor = await this.getReconnectCursor(session.sessionId);
         const cursor = request.cursor ?? storedCursor ?? 0;
         const metadata = {
+            ...(request.metadata || {}),
             clientId: fullClientId(session.clientId),
             requestId: session.requestId,
             sessionId: session.sessionId,
@@ -633,6 +667,7 @@ export class AureloSDK {
                 aureloAction: 'reconnect',
                 cursor,
             },
+            context: request.context,
         };
         const response = await this.fetchImpl(`${this.baseUrl}/v1/responses`, {
             method: 'POST',
@@ -654,6 +689,8 @@ export class AureloSDK {
                     model: body.model,
                     input: body.input,
                     stream: true,
+                    metadata: request.metadata,
+                    context: request.context,
                 }, { signal: request.signal });
             }
             throw new AureloSDKError(`Aurelo reconnect failed with HTTP ${response.status}`, {
@@ -665,6 +702,76 @@ export class AureloSDK {
         }
         return 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();
+        if (!callId) {
+            throw new Error('AureloSDK submitToolResult requires callId.');
+        }
+        const metadata = {
+            ...(request.metadata || {}),
+            aureloAction: 'tool_result',
+            clientId: fullClientId(session.clientId),
+            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: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            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,
+                callId,
+                tools: request.tools || request.context?.tools,
+                context: request.context,
+                output: request.output,
+                result: request.result,
+                error: request.error,
+                metadata,
+            }),
+            signal: request.signal,
+        });
+        if (!response.ok) {
+            const payload = await this.readErrorPayload(response);
+            const rotation = shouldRotate(payload);
+            if (rotation.rotate) {
+                await this.rotateSession(rotation.reason || 'backend_rotation');
+            }
+            throw new AureloSDKError(`Aurelo tool result submit failed with HTTP ${response.status}`, {
+                status: response.status,
+                reason: rotation.reason,
+                rotateSession: rotation.rotate,
+                payload,
+            });
+        }
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('text/event-stream')) {
+            return response;
+        }
+        return this.readResponsePayload(response);
+    }
+    async *streamToolResult(request) {
+        const result = await this.submitToolResult({ ...request, stream: true });
+        if (result instanceof Response) {
+            yield* this.streamEventsFromResponse(result);
+            return;
+        }
+        yield { type: 'event', raw: '', data: result };
+    }
     async handleSseLine(line) {
         const trimmed = line.trim();
         if (!trimmed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aurelo_npm/sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Aurelo API-key SDK with stable client identity and backend-driven session rotation.",
   "type": "module",
   "main": "./dist/index.js",