aurelo.ai 0.0.2

package/dist/index.js

@@ -0,0 +1,1178 @@
+export class AureloSDKError extends Error {
+    status;
+    reason;
+    rotateSession;
+    payload;
+    constructor(message, options) {
+        super(message);
+        this.name = 'AureloSDKError';
+        this.status = options.status;
+        this.reason = options.reason || '';
+        this.rotateSession = !!options.rotateSession;
+        this.payload = options.payload;
+    }
+}
+const CLIENT_ID_KEY = 'aurelo.sdk.clientId';
+const SESSION_KEY = 'aurelo.sdk.session';
+const MODEL_SESSIONS_KEY = 'aurelo.sdk.modelSessions';
+const RECONNECT_CURSOR_KEY_PREFIX = 'aurelo.sdk.reconnectCursor.';
+const ROTATION_REASONS = new Set([
+    'input_threshold_reached',
+    'output_threshold_reached',
+    'no_active_runtime',
+    'no_active_reconnect_stream',
+    'window_expired',
+    'session_rollover_pending',
+    'request_closed',
+    'response_completed',
+    'response_done',
+    'tracked_user_mismatch',
+    'model_changed',
+    'session_model_changed',
+]);
+class MemoryStorage {
+    values = new Map();
+    get(key) {
+        return this.values.get(key) || null;
+    }
+    set(key, value) {
+        this.values.set(key, value);
+    }
+    delete(key) {
+        this.values.delete(key);
+    }
+}
+function createDefaultStorage() {
+    const localStorageRef = globalThis.localStorage;
+    if (localStorageRef) {
+        return {
+            get: (key) => localStorageRef.getItem(key),
+            set: (key, value) => localStorageRef.setItem(key, value),
+            delete: (key) => localStorageRef.removeItem(key),
+        };
+    }
+    return new MemoryStorage();
+}
+function normalizeBaseUrl(value) {
+    return String(value || '').trim().replace(/\/+$/, '') || 'https://aurelo.tech';
+}
+function randomId() {
+    const cryptoRef = globalThis.crypto;
+    if (cryptoRef && typeof cryptoRef.randomUUID === 'function') {
+        return cryptoRef.randomUUID().replace(/-/g, '');
+    }
+    const parts = new Uint8Array(16);
+    if (cryptoRef && typeof cryptoRef.getRandomValues === 'function') {
+        cryptoRef.getRandomValues(parts);
+        return Array.from(parts, (part) => part.toString(16).padStart(2, '0')).join('');
+    }
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+}
+function normalizeClientId(value) {
+    const trimmed = String(value || '').trim();
+    const withoutPrefix = trimmed.startsWith('ext_') ? trimmed.slice(4) : trimmed;
+    return withoutPrefix.replace(/[^A-Za-z0-9_-]/g, '') || randomId();
+}
+function fullClientId(clientId) {
+    return clientId.startsWith('ext_') ? clientId : `ext_${clientId}`;
+}
+function createRequestId() {
+    return `req_${randomId()}`;
+}
+function createSession(clientId, model) {
+    const requestId = createRequestId();
+    const session = {
+        clientId,
+        requestId,
+        sessionId: `${fullClientId(clientId)}_${requestId}`,
+        createdAt: Date.now(),
+        status: 'active',
+    };
+    const modelKey = normalizeSessionModel(model);
+    if (modelKey) {
+        session.model = modelKey;
+    }
+    return session;
+}
+function normalizeSessionModel(model) {
+    return String(model || '').trim().toLowerCase();
+}
+function modelForOutbound(model, fallback = 'M1') {
+    const raw = String(model || '').trim();
+    if (!raw) {
+        return fallback;
+    }
+    const normalized = raw.toLowerCase();
+    if (normalized === 'm1' || normalized === 'm2' || normalized === 'x1' || normalized === 'x2') {
+        return normalized.toUpperCase();
+    }
+    const compact = normalized.replace(/[\s_-]+/g, '');
+    if (compact === 'm1long' || compact === 'm1longcontext') {
+        return 'M1 - Long Context';
+    }
+    if (compact === 'm2long' || compact === 'm2longcontext') {
+        return 'M2 - Long Context';
+    }
+    return raw;
+}
+function parseStoredJson(stored) {
+    if (!stored) {
+        return null;
+    }
+    if (typeof stored === 'string') {
+        try {
+            return JSON.parse(stored);
+        }
+        catch {
+            return null;
+        }
+    }
+    if (typeof stored === 'object') {
+        return stored;
+    }
+    return null;
+}
+function sessionMatchesModel(session, modelKey) {
+    if (!modelKey) {
+        return true;
+    }
+    return normalizeSessionModel(session?.model) === modelKey;
+}
+function requestIdFromSessionId(sessionId) {
+    const normalizedSessionId = String(sessionId || '').trim();
+    const markerIndex = normalizedSessionId.lastIndexOf('_req_');
+    if (markerIndex < 0) {
+        return '';
+    }
+    return normalizedSessionId.slice(markerIndex + 1);
+}
+function clientIdFromSessionId(sessionId) {
+    const normalizedSessionId = String(sessionId || '').trim();
+    const markerIndex = normalizedSessionId.lastIndexOf('_req_');
+    if (markerIndex <= 0) {
+        return '';
+    }
+    return normalizedSessionId.slice(0, markerIndex);
+}
+function reconnectCursorKey(sessionId) {
+    return `${RECONNECT_CURSOR_KEY_PREFIX}${sessionId}`;
+}
+export function createAureloClientId() {
+    return randomId();
+}
+export function normalizeAureloClientId(value) {
+    return normalizeClientId(value);
+}
+export function getAureloFullClientId(clientId) {
+    return fullClientId(normalizeClientId(clientId));
+}
+export function createAureloRequestId() {
+    return createRequestId();
+}
+export function createAureloSession(clientId, model) {
+    return createSession(normalizeClientId(clientId), model);
+}
+function readReason(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+    const value = payload;
+    const billing = value.billing && typeof value.billing === 'object'
+        ? value.billing
+        : null;
+    const rolloverReason = typeof billing?.rolloverReason === 'string' ? billing.rolloverReason : '';
+    if (rolloverReason === 'input') {
+        return 'input_threshold_reached';
+    }
+    if (rolloverReason === 'output') {
+        return 'output_threshold_reached';
+    }
+    if (billing?.rolloverTriggered === true) {
+        return 'session_rollover_pending';
+    }
+    return String(value.reason || value.code || '').trim();
+}
+function shouldRotate(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return { rotate: false, reason: '' };
+    }
+    const value = payload;
+    const reason = readReason(payload);
+    const billing = value.billing && typeof value.billing === 'object'
+        ? value.billing
+        : null;
+    const rotate = value.rotateSession === true ||
+        ROTATION_REASONS.has(reason) ||
+        billing?.rolloverTriggered === true;
+    return { rotate, reason };
+}
+function parseSseRotationComment(comment) {
+    if (!comment.includes('aurelo-rotate-session')) {
+        return null;
+    }
+    const reasonMatch = comment.match(/\breason=([^\s]+)/);
+    const sessionMatch = comment.match(/\bsessionId=([^\s]+)/);
+    return {
+        reason: reasonMatch ? reasonMatch[1] : 'request_closed',
+        sessionId: sessionMatch ? sessionMatch[1] : '',
+    };
+}
+function getPayloadSessionId(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+    const value = payload;
+    const readSessionId = (record) => {
+        if (!record) {
+            return '';
+        }
+        const metadata = record.metadata && typeof record.metadata === 'object'
+            ? record.metadata
+            : null;
+        return String(record.sessionId || record.session_id || metadata?.sessionId || metadata?.session_id || '').trim();
+    };
+    const directSessionId = readSessionId(value);
+    if (directSessionId) {
+        return directSessionId;
+    }
+    const response = value.response && typeof value.response === 'object'
+        ? value.response
+        : null;
+    const responseSessionId = readSessionId(response);
+    if (responseSessionId) {
+        return responseSessionId;
+    }
+    const item = value.item && typeof value.item === 'object'
+        ? value.item
+        : null;
+    const itemSessionId = readSessionId(item);
+    if (itemSessionId) {
+        return itemSessionId;
+    }
+    const metadata = value.metadata && typeof value.metadata === 'object'
+        ? value.metadata
+        : null;
+    return String(value.sessionId || value.session_id || metadata?.sessionId || metadata?.session_id || '').trim();
+}
+function parseReconnectCursorComment(comment) {
+    if (!comment.includes('aurelo-reconnect-close')) {
+        return null;
+    }
+    const sessionMatch = comment.match(/\bsessionId=([^\s]+)/);
+    const cursorMatch = comment.match(/\bcursor=([0-9]+)/);
+    if (!sessionMatch || !cursorMatch) {
+        return null;
+    }
+    return {
+        sessionId: sessionMatch[1],
+        cursor: Number(cursorMatch[1]) || 0,
+    };
+}
+function isTerminalResponseType(type) {
+    return type === 'response.completed' || type === 'response.done';
+}
+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 '';
+    }
+    const value = payload;
+    return String(value.error || value.message || '').trim();
+}
+export class AureloSessionManager {
+    storage;
+    clientIdValue = null;
+    sessionValue = null;
+    constructor(options = {}) {
+        this.storage = options.storage || createDefaultStorage();
+        if (options.clientId) {
+            this.clientIdValue = normalizeClientId(options.clientId);
+        }
+    }
+    async getClientId() {
+        if (this.clientIdValue) {
+            return this.clientIdValue;
+        }
+        const stored = await this.storage.get(CLIENT_ID_KEY);
+        if (stored && stored.trim()) {
+            this.clientIdValue = normalizeClientId(stored);
+            return this.clientIdValue;
+        }
+        this.clientIdValue = randomId();
+        await this.storage.set(CLIENT_ID_KEY, this.clientIdValue);
+        return this.clientIdValue;
+    }
+    async getFullClientId() {
+        return fullClientId(await this.getClientId());
+    }
+    async getStoredModelSessions() {
+        return parseStoredJson(await this.storage.get(MODEL_SESSIONS_KEY)) || {};
+    }
+    async saveSession(session) {
+        this.sessionValue = session;
+        await this.storage.set(SESSION_KEY, JSON.stringify(session));
+        const modelKey = normalizeSessionModel(session.model);
+        if (modelKey) {
+            const sessions = await this.getStoredModelSessions();
+            sessions[modelKey] = session;
+            await this.storage.set(MODEL_SESSIONS_KEY, JSON.stringify(sessions));
+        }
+    }
+    async getSession(model) {
+        const modelKey = normalizeSessionModel(model);
+        if (this.sessionValue &&
+            this.sessionValue.status === 'active' &&
+            sessionMatchesModel(this.sessionValue, modelKey)) {
+            return this.sessionValue;
+        }
+        if (modelKey) {
+            const modelSession = (await this.getStoredModelSessions())[modelKey];
+            if (modelSession?.sessionId &&
+                modelSession.status === 'active' &&
+                (!modelSession.model || sessionMatchesModel(modelSession, modelKey))) {
+                this.sessionValue = modelSession;
+                return modelSession;
+            }
+        }
+        const stored = await this.storage.get(SESSION_KEY);
+        const parsed = parseStoredJson(stored);
+        if (parsed?.sessionId && parsed.status === 'active' && sessionMatchesModel(parsed, modelKey)) {
+            this.sessionValue = parsed;
+            return parsed;
+        }
+        return this.rotateSession('initial', modelKey || undefined);
+    }
+    async getStoredActiveSession(model) {
+        const modelKey = normalizeSessionModel(model);
+        if (this.sessionValue &&
+            this.sessionValue.status === 'active' &&
+            sessionMatchesModel(this.sessionValue, modelKey)) {
+            return this.sessionValue;
+        }
+        if (modelKey) {
+            const modelSession = (await this.getStoredModelSessions())[modelKey];
+            if (modelSession?.sessionId &&
+                modelSession.status === 'active' &&
+                (!modelSession.model || sessionMatchesModel(modelSession, modelKey))) {
+                this.sessionValue = modelSession;
+                return modelSession;
+            }
+        }
+        const stored = await this.storage.get(SESSION_KEY);
+        const parsed = parseStoredJson(stored);
+        if (parsed?.sessionId && parsed.status === 'active' && sessionMatchesModel(parsed, modelKey)) {
+            this.sessionValue = parsed;
+            return parsed;
+        }
+        return null;
+    }
+    async getSessionSelection(model) {
+        const existing = await this.getStoredActiveSession(model);
+        if (existing) {
+            return { session: existing, created: false };
+        }
+        return { session: await this.rotateSession('initial', model), created: true };
+    }
+    async rotateSession(reason = 'manual', model) {
+        const clientId = await this.getClientId();
+        this.sessionValue = createSession(clientId, model);
+        this.sessionValue.rotationReason = reason;
+        await this.saveSession(this.sessionValue);
+        return this.sessionValue;
+    }
+    async closeSession(reason = 'request_closed', model) {
+        const session = await this.getStoredActiveSession(model);
+        if (!session) {
+            return;
+        }
+        this.sessionValue = {
+            ...session,
+            status: 'closed',
+            rotationReason: reason,
+        };
+        await this.saveSession(this.sessionValue);
+    }
+}
+export class AureloSDK {
+    apiKey;
+    baseUrl;
+    fetchImpl;
+    storage;
+    clientIdValue = null;
+    sessionValue = null;
+    reconnectCursors = new Map();
+    observedStreamResponses = new WeakSet();
+    observedStreamResponseSessions = new WeakMap();
+    observedSseComments = new Set();
+    observedSseCommentOrder = [];
+    constructor(options) {
+        if (!options.apiKey || !String(options.apiKey).trim()) {
+            throw new Error('AureloSDK requires apiKey.');
+        }
+        this.apiKey = String(options.apiKey).trim();
+        this.baseUrl = normalizeBaseUrl(options.baseUrl || 'https://aurelo.tech');
+        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);
+        }
+    }
+    async getClientId() {
+        if (this.clientIdValue) {
+            return this.clientIdValue;
+        }
+        const stored = await this.storage.get(CLIENT_ID_KEY);
+        if (stored && stored.trim()) {
+            this.clientIdValue = normalizeClientId(stored);
+            return this.clientIdValue;
+        }
+        this.clientIdValue = randomId();
+        await this.storage.set(CLIENT_ID_KEY, this.clientIdValue);
+        return this.clientIdValue;
+    }
+    async getFullClientId() {
+        return fullClientId(await this.getClientId());
+    }
+    async getStoredModelSessions() {
+        return parseStoredJson(await this.storage.get(MODEL_SESSIONS_KEY)) || {};
+    }
+    async saveSession(session) {
+        this.sessionValue = session;
+        await this.storage.set(SESSION_KEY, JSON.stringify(session));
+        const modelKey = normalizeSessionModel(session.model);
+        if (modelKey) {
+            const sessions = await this.getStoredModelSessions();
+            sessions[modelKey] = session;
+            await this.storage.set(MODEL_SESSIONS_KEY, JSON.stringify(sessions));
+        }
+    }
+    async findModelForSessionId(sessionId) {
+        const normalizedSessionId = String(sessionId || '').trim();
+        if (!normalizedSessionId) {
+            return '';
+        }
+        const session = await this.findSessionById(normalizedSessionId);
+        return normalizeSessionModel(session?.model);
+    }
+    async findSessionById(sessionId) {
+        const normalizedSessionId = String(sessionId || '').trim();
+        if (!normalizedSessionId) {
+            return null;
+        }
+        if (this.sessionValue?.sessionId === normalizedSessionId) {
+            return this.sessionValue;
+        }
+        const sessions = await this.getStoredModelSessions();
+        for (const [modelKey, session] of Object.entries(sessions)) {
+            if (session?.sessionId === normalizedSessionId) {
+                return {
+                    ...session,
+                    model: normalizeSessionModel(session.model || modelKey) || session.model,
+                };
+            }
+        }
+        const stored = await this.storage.get(SESSION_KEY);
+        const parsed = parseStoredJson(stored);
+        if (parsed?.sessionId === normalizedSessionId) {
+            return parsed;
+        }
+        return null;
+    }
+    async getSession(model) {
+        return (await this.getSessionSelection(model)).session;
+    }
+    async getStoredActiveSession(model) {
+        const modelKey = normalizeSessionModel(model);
+        if (this.sessionValue &&
+            this.sessionValue.status === 'active' &&
+            sessionMatchesModel(this.sessionValue, modelKey)) {
+            return this.sessionValue;
+        }
+        if (modelKey) {
+            const modelSession = (await this.getStoredModelSessions())[modelKey];
+            if (modelSession?.sessionId &&
+                modelSession.status === 'active' &&
+                (!modelSession.model || sessionMatchesModel(modelSession, modelKey))) {
+                this.sessionValue = modelSession;
+                return modelSession;
+            }
+        }
+        const stored = await this.storage.get(SESSION_KEY);
+        const parsed = parseStoredJson(stored);
+        if (parsed?.sessionId && parsed.status === 'active' && sessionMatchesModel(parsed, modelKey)) {
+            this.sessionValue = parsed;
+            return parsed;
+        }
+        return null;
+    }
+    async getSessionSelection(model) {
+        const existing = await this.getStoredActiveSession(model);
+        if (existing) {
+            return { session: existing, created: false };
+        }
+        return { session: await this.rotateSession('initial', model), created: true };
+    }
+    async rotateSession(reason = 'manual', model) {
+        const modelKey = normalizeSessionModel(model);
+        const previousSessionId = modelKey
+            ? (await this.getStoredActiveSession(modelKey))?.sessionId
+            : this.sessionValue?.sessionId;
+        const clientId = await this.getClientId();
+        this.sessionValue = createSession(clientId, modelKey || undefined);
+        this.sessionValue.rotationReason = reason;
+        if (previousSessionId) {
+            await this.clearReconnectCursor(previousSessionId);
+        }
+        await this.saveSession(this.sessionValue);
+        return this.sessionValue;
+    }
+    async closeSession(reason = 'request_closed', model) {
+        const session = await this.getStoredActiveSession(model);
+        if (!session) {
+            return;
+        }
+        this.sessionValue = {
+            ...session,
+            status: 'closed',
+            rotationReason: reason,
+        };
+        await this.clearReconnectCursor(session.sessionId);
+        await this.saveSession(this.sessionValue);
+    }
+    async markSessionClosed(session, reason = 'request_closed') {
+        this.sessionValue = {
+            ...session,
+            status: 'closed',
+            rotationReason: reason,
+        };
+        await this.clearReconnectCursor(session.sessionId);
+        await this.saveSession(this.sessionValue);
+    }
+    async getReconnectCursor(sessionId) {
+        if (this.reconnectCursors.has(sessionId)) {
+            return this.reconnectCursors.get(sessionId) ?? null;
+        }
+        const stored = await this.storage.get(reconnectCursorKey(sessionId));
+        if (!stored) {
+            return null;
+        }
+        const cursor = Number(stored);
+        if (!Number.isFinite(cursor) || cursor < 0) {
+            return null;
+        }
+        this.reconnectCursors.set(sessionId, cursor);
+        return cursor;
+    }
+    async setReconnectCursor(sessionId, cursor) {
+        const normalizedCursor = Math.max(0, Math.floor(cursor));
+        this.reconnectCursors.set(sessionId, normalizedCursor);
+        await this.storage.set(reconnectCursorKey(sessionId), String(normalizedCursor));
+    }
+    async clearReconnectCursor(sessionId) {
+        this.reconnectCursors.delete(sessionId);
+        if (this.storage.delete) {
+            await this.storage.delete(reconnectCursorKey(sessionId));
+        }
+        else {
+            await this.storage.set(reconnectCursorKey(sessionId), '');
+        }
+    }
+    async observeSseComment(comment) {
+        const normalizedComment = String(comment || '').trim();
+        if (!normalizedComment) {
+            return;
+        }
+        if (this.rememberSseComment(normalizedComment)) {
+            return;
+        }
+        const reconnectCursor = parseReconnectCursorComment(normalizedComment);
+        if (reconnectCursor) {
+            await this.setReconnectCursor(reconnectCursor.sessionId, reconnectCursor.cursor);
+        }
+        const rotation = parseSseRotationComment(normalizedComment);
+        if (rotation) {
+            const model = rotation.sessionId ? await this.findModelForSessionId(rotation.sessionId) : '';
+            await this.rotateSession(rotation.reason, model || undefined);
+        }
+    }
+    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 continueWithMessage(request) {
+        const continuationRequest = typeof request === 'string'
+            ? { message: request }
+            : request;
+        const message = String(continuationRequest.message || '').trim();
+        if (!message) {
+            throw new Error('AureloSDK continueWithMessage requires message.');
+        }
+        return this.createResponseWithRotationRetry({
+            model: continuationRequest.model || continuationRequest.publicModel || 'M1',
+            input: message,
+            stream: true,
+            sessionId: continuationRequest.sessionId,
+            requestId: continuationRequest.requestId,
+            metadata: {
+                ...(continuationRequest.metadata || {}),
+                aureloAction: 'continue_or_create',
+                sessionId: continuationRequest.sessionId,
+                requestId: continuationRequest.requestId,
+                source: continuationRequest.source || 'aurelo-sdk',
+            },
+            context: continuationRequest.context,
+        }, { signal: continuationRequest.signal });
+    }
+    async createResponse(request, options = {}) {
+        const { session, explicitOverride, created } = await this.resolveOutboundSession(request);
+        const metadata = {
+            ...(request.metadata || {}),
+            model: (request.metadata || {}).model || request.model,
+            clientId: fullClientId(session.clientId),
+            requestId: session.requestId,
+            sessionId: session.sessionId,
+            aureloSessionState: created ? 'new' : 'active',
+            aureloSessionCreated: created,
+        };
+        const { sessionId: _sessionId, session_id: _sessionIdSnake, requestId: _requestId, request_id: _requestIdSnake, latestInput: _latestInput, sessionStartInput: _sessionStartInput, fullContextInput: _fullContextInput, rotationRetryInput: _rotationRetryInput, ...requestBody } = request;
+        const sessionStartInput = request.sessionStartInput ?? request.fullContextInput ?? request.rotationRetryInput;
+        if (!explicitOverride && created && sessionStartInput !== undefined) {
+            requestBody.input = sessionStartInput;
+        }
+        else if (!explicitOverride && !created && request.latestInput !== undefined) {
+            requestBody.input = request.latestInput;
+        }
+        const body = {
+            ...requestBody,
+            metadata,
+        };
+        const response = await this.fetchImpl(`${this.baseUrl}/v1/responses`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+            signal: options.signal,
+        });
+        if (!response.ok) {
+            const payload = await this.readErrorPayload(response);
+            const rotation = shouldRotate(payload);
+            const reason = rotation.reason || `http_${response.status}`;
+            const payloadMessage = getPayloadErrorMessage(payload);
+            await this.markSessionClosed(session, reason);
+            throw new AureloSDKError(`Aurelo request failed with HTTP ${response.status}${rotation.reason ? ` (${rotation.reason})` : ''}${payloadMessage ? `: ${payloadMessage}` : ''}`, {
+                status: response.status,
+                reason: rotation.reason,
+                rotateSession: rotation.rotate,
+                payload,
+            });
+        }
+        const responseSessionId = response.headers.get('x-aurelo-session-id');
+        if (!explicitOverride && responseSessionId && responseSessionId !== session.sessionId) {
+            const updatedSession = {
+                ...session,
+                clientId: clientIdFromSessionId(responseSessionId) || session.clientId,
+                requestId: requestIdFromSessionId(responseSessionId) || session.requestId,
+                sessionId: responseSessionId,
+            };
+            await this.clearReconnectCursor(session.sessionId);
+            await this.saveSession(updatedSession);
+        }
+        return this.observeResponseStream(response, responseSessionId || session.sessionId);
+    }
+    async createResponseWithRotationRetry(request, options = {}) {
+        try {
+            return await this.createResponse(request, options);
+        }
+        catch (error) {
+            if (isAureloSdkError(error) && error.rotateSession && !this.hasRequestSessionOverride(request)) {
+                return this.createResponse(request, options);
+            }
+            throw error;
+        }
+    }
+    async createOrContinueResponse(request, options = {}) {
+        return this.createResponseWithRotationRetry({
+            ...request,
+            metadata: {
+                ...(request.metadata || {}),
+                aureloAction: 'continue_or_create',
+            },
+        }, options);
+    }
+    async *streamResponse(request, options = {}) {
+        const response = await this.createResponseWithRotationRetry({ ...request, stream: true }, options);
+        yield* this.streamEventsFromResponse(response);
+    }
+    async *streamReconnect(request = {}) {
+        const response = await this.reconnect(request);
+        yield* this.streamEventsFromResponse(response);
+    }
+    async *continueResponse(message, request = {}) {
+        const model = request.model || request.publicModel || 'M1';
+        const response = await this.createResponseWithRotationRetry({
+            model,
+            input: message,
+            stream: true,
+            sessionId: request.sessionId,
+            requestId: request.requestId,
+            metadata: {
+                ...(request.metadata || {}),
+                aureloAction: 'continue_or_create',
+                sessionId: request.sessionId,
+                requestId: request.requestId,
+            },
+            context: request.context,
+        }, { signal: request.signal });
+        yield* this.streamEventsFromResponse(response);
+    }
+    hasRequestSessionOverride(request) {
+        const metadata = request.metadata || {};
+        return Boolean(String(request.sessionId || request.session_id || metadata.sessionId || metadata.session_id || '').trim() ||
+            String(request.requestId || request.request_id || metadata.requestId || metadata.request_id || '').trim());
+    }
+    async resolveOutboundSession(request) {
+        const model = normalizeSessionModel(request.model || request.metadata?.model);
+        const metadata = request.metadata || {};
+        const sessionId = String(request.sessionId ||
+            request.session_id ||
+            metadata.sessionId ||
+            metadata.session_id ||
+            '').trim();
+        const requestId = String(request.requestId ||
+            request.request_id ||
+            metadata.requestId ||
+            metadata.request_id ||
+            '').trim();
+        if (!sessionId && !requestId) {
+            const selection = await this.getSessionSelection(model || undefined);
+            const session = selection.session;
+            return { session, explicitOverride: false, created: selection.created };
+        }
+        const explicitSession = sessionId ? await this.findSessionById(sessionId) : null;
+        const fallbackSelection = explicitSession || sessionId
+            ? null
+            : await this.getSessionSelection(model || undefined);
+        const fallbackSession = explicitSession || fallbackSelection?.session;
+        const derivedClientId = sessionId ? clientIdFromSessionId(sessionId) : '';
+        const derivedRequestId = sessionId ? requestIdFromSessionId(sessionId) : '';
+        const clientId = fallbackSession?.clientId || derivedClientId || await this.getClientId();
+        return {
+            session: {
+                clientId,
+                requestId: requestId || fallbackSession?.requestId || derivedRequestId || createRequestId(),
+                sessionId: sessionId || fallbackSession?.sessionId || `${fullClientId(clientId)}_${requestId || createRequestId()}`,
+                createdAt: fallbackSession?.createdAt || Date.now(),
+                status: fallbackSession?.status || 'active',
+                rotationReason: fallbackSession?.rotationReason,
+                model: model || fallbackSession?.model,
+            },
+            explicitOverride: true,
+            created: false,
+        };
+    }
+    async *streamEventsFromResponse(response) {
+        if (!response.body) {
+            yield { type: 'done', raw: '' };
+            await this.closeSession('request_closed');
+            return;
+        }
+        const observeComments = !this.observedStreamResponses.has(response);
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    const event = await this.handleSseLine(line, {
+                        observeComments,
+                        sessionId: this.observedStreamResponseSessions.get(response) || response.headers.get('x-aurelo-session-id') || '',
+                    });
+                    if (event) {
+                        yield event;
+                    }
+                }
+            }
+            buffer += decoder.decode();
+            if (buffer.trim()) {
+                const event = await this.handleSseLine(buffer, {
+                    observeComments,
+                    sessionId: this.observedStreamResponseSessions.get(response) || response.headers.get('x-aurelo-session-id') || '',
+                });
+                if (event) {
+                    yield event;
+                }
+            }
+            yield { type: 'done', raw: '' };
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+    async reconnect(request = {}) {
+        const model = normalizeSessionModel(request.model || request.metadata?.model);
+        const requestedSessionId = String(request.sessionId || '').trim();
+        const explicitSession = requestedSessionId ? await this.findSessionById(requestedSessionId) : null;
+        const sessionModel = model || normalizeSessionModel(explicitSession?.model);
+        const session = requestedSessionId
+            ? {
+                clientId: explicitSession?.clientId || clientIdFromSessionId(requestedSessionId) || await this.getClientId(),
+                requestId: explicitSession?.requestId || requestIdFromSessionId(requestedSessionId) || createRequestId(),
+                sessionId: requestedSessionId,
+                createdAt: explicitSession?.createdAt || Date.now(),
+                status: explicitSession?.status || 'active',
+                rotationReason: explicitSession?.rotationReason,
+                model: sessionModel || explicitSession?.model,
+            }
+            : await this.getSession(model || undefined);
+        const storedCursor = await this.getReconnectCursor(session.sessionId);
+        const cursor = request.cursor ?? storedCursor ?? 0;
+        const effectiveModel = modelForOutbound(request.model || request.metadata?.model || session.model);
+        const metadata = {
+            ...(request.metadata || {}),
+            model: request.metadata?.model || effectiveModel,
+            clientId: fullClientId(session.clientId),
+            requestId: session.requestId,
+            sessionId: session.sessionId,
+        };
+        const body = {
+            model: effectiveModel,
+            input: request.input || '',
+            stream: true,
+            metadata: {
+                ...metadata,
+                aureloAction: 'reconnect',
+                cursor,
+            },
+            context: request.context,
+        };
+        const response = await this.fetchImpl(`${this.baseUrl}/v1/responses`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(body),
+            signal: request.signal,
+        });
+        if (!response.ok) {
+            const payload = await this.readErrorPayload(response);
+            const rotation = shouldRotate(payload);
+            if (rotation.rotate) {
+                const payloadSessionModel = await this.findModelForSessionId(getPayloadSessionId(payload));
+                await this.rotateSession(rotation.reason || 'backend_rotation', payloadSessionModel || model || undefined);
+            }
+            if (rotation.rotate && String(payload?.nextAction || '') === 'start_new_request') {
+                return this.createResponse({
+                    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}`, {
+                status: response.status,
+                reason: rotation.reason,
+                rotateSession: rotation.rotate,
+                payload,
+            });
+        }
+        return this.observeResponseStream(response, session.sessionId);
+    }
+    async submitToolResult(request) {
+        const requestedSessionId = String(request.sessionId ||
+            request.toolCall?.sessionId ||
+            request.toolCall?.session_id ||
+            '').trim();
+        const explicitSession = requestedSessionId ? await this.findSessionById(requestedSessionId) : null;
+        const activeSession = explicitSession || (requestedSessionId
+            ? {
+                clientId: clientIdFromSessionId(requestedSessionId) || await this.getClientId(),
+                requestId: requestIdFromSessionId(requestedSessionId) || createRequestId(),
+                sessionId: requestedSessionId,
+                model: normalizeSessionModel(request.model || request.publicModel) || undefined,
+                createdAt: Date.now(),
+                status: 'active',
+            }
+            : await this.getSession(request.model || request.publicModel));
+        const sessionId = String(requestedSessionId ||
+            activeSession.sessionId).trim();
+        const requestId = String(request.requestId ||
+            request.toolCall?.requestId ||
+            request.toolCall?.request_id ||
+            activeSession.requestId ||
+            requestIdFromSessionId(sessionId)).trim();
+        const callId = String(request.callId ||
+            request.call_id ||
+            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.');
+        }
+        const effectiveModel = modelForOutbound(request.model || request.publicModel || activeSession.model);
+        const metadata = {
+            ...(request.metadata || {}),
+            aureloAction: 'tool_result',
+            clientId: fullClientId(activeSession.clientId),
+            requestId,
+            sessionId,
+            call_id: callId,
+            callId,
+            toolCallId: callId,
+            tool_call_id: callId,
+            model: effectiveModel,
+        };
+        const response = await this.fetchImpl(`${this.baseUrl}/v1/responses`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: effectiveModel,
+                publicModel: request.publicModel || request.model || effectiveModel,
+                stream: request.stream !== false,
+                sessionId,
+                requestId,
+                call_id: callId,
+                callId,
+                toolCallId: callId,
+                tool_call_id: 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) {
+                const payloadSessionModel = await this.findModelForSessionId(getPayloadSessionId(payload) || sessionId);
+                await this.rotateSession(rotation.reason || 'backend_rotation', payloadSessionModel || request.model || request.publicModel);
+            }
+            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 this.observeResponseStream(response, sessionId);
+        }
+        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 };
+    }
+    observeResponseStream(response, sessionId = '') {
+        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, sessionId);
+                            controller.enqueue(value);
+                        }
+                    }
+                    const trailing = decoder.decode();
+                    if (trailing) {
+                        buffer = await this.observeSseTextFragment(trailing, buffer, sessionId);
+                    }
+                    if (buffer.trim()) {
+                        await this.handleSseLine(buffer, { sessionId });
+                    }
+                    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);
+        if (sessionId) {
+            this.observedStreamResponseSessions.set(observedResponse, sessionId);
+        }
+        return observedResponse;
+    }
+    async observeSseTextFragment(fragment, previousBuffer, sessionId = '') {
+        if (!fragment) {
+            return previousBuffer;
+        }
+        const lines = `${previousBuffer}${fragment}`.split(/\r?\n/);
+        const buffer = lines.pop() || '';
+        for (const line of lines) {
+            await this.handleSseLine(line, { sessionId });
+        }
+        return buffer;
+    }
+    async handleSseLine(line, options = {}) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return null;
+        }
+        if (trimmed.startsWith(':')) {
+            const comment = trimmed.slice(1).trim();
+            if (options.observeComments !== false) {
+                await this.observeSseComment(comment);
+            }
+            return { type: 'comment', raw: line, comment };
+        }
+        if (trimmed === 'data: [DONE]') {
+            await this.closeSessionForPayloadSession(options.sessionId || '', 'request_closed');
+            return { type: 'done', raw: line };
+        }
+        if (!trimmed.startsWith('data: ')) {
+            return { type: 'event', raw: line, data: trimmed };
+        }
+        let data = trimmed.slice(6);
+        try {
+            data = JSON.parse(trimmed.slice(6));
+        }
+        catch { }
+        const eventType = data && typeof data === 'object'
+            ? String(data.type || '')
+            : '';
+        const rotation = shouldRotate(data);
+        if (rotation.rotate) {
+            const model = await this.findModelForSessionId(getPayloadSessionId(data) || options.sessionId || '');
+            await this.rotateSession(rotation.reason || 'backend_rotation', model || undefined);
+        }
+        else if (isTerminalResponseType(eventType)) {
+            await this.closeSessionForPayloadSession(getPayloadSessionId(data) || options.sessionId || '', eventType === 'response.done' ? 'response_done' : 'response_completed');
+        }
+        return { type: 'event', raw: line, data };
+    }
+    async closeSessionForPayloadSession(sessionId, reason) {
+        const normalizedSessionId = String(sessionId || '').trim();
+        if (normalizedSessionId) {
+            const session = await this.findSessionById(normalizedSessionId);
+            if (session) {
+                await this.markSessionClosed(session, reason);
+                return;
+            }
+            const model = await this.findModelForSessionId(normalizedSessionId);
+            if (model) {
+                await this.closeSession(reason, model);
+            }
+            return;
+        }
+        await this.closeSession(reason);
+    }
+    async readErrorPayload(response) {
+        const text = await response.text();
+        if (!text) {
+            return null;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return { error: text };
+        }
+    }
+    async readResponsePayload(response) {
+        const text = await response.text();
+        if (!text) {
+            return null;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+}
+export default AureloSDK;