@attrove/sdk 0.1.5 → 0.1.7

package/cjs/{src/utils → utils}/fetch.js

@@ -7,9 +7,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
-const errors_1 = require("../errors");
-const types_1 = require("../types");
-const constants_1 = require("../constants");
+const index_js_1 = require("../errors/index.js");
+const index_js_2 = require("../types/index.js");
+const constants_js_1 = require("../constants.js");
 /**
  * Delay execution during retry backoff.
  * Used between retry attempts to avoid overwhelming the server.
@@ -25,7 +25,7 @@ function calculateRetryDelay(attempt, retryAfter) {
         return retryAfter * 1000;
     }
     // Exponential backoff with jitter
-    const exponentialDelay = constants_1.INITIAL_RETRY_DELAY * Math.pow(2, attempt);
+    const exponentialDelay = constants_js_1.INITIAL_RETRY_DELAY * Math.pow(2, attempt);
     const jitter = Math.random() * 0.3 * exponentialDelay;
     return Math.floor(exponentialDelay + jitter);
 }
@@ -57,32 +57,36 @@ function normalizeConfig(config) {
     let auth;
     // Check for partial API key credentials
     if (config.apiKey && !config.userId) {
-        throw new errors_1.ValidationError('userId is required when using apiKey authentication', types_1.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: 'userId', providedFields: ['apiKey'] });
+        throw new index_js_1.ValidationError("userId is required when using apiKey authentication", index_js_2.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: "userId", providedFields: ["apiKey"] });
     }
     if (!config.apiKey && config.userId) {
-        throw new errors_1.ValidationError('apiKey is required when using user authentication', types_1.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: 'apiKey', providedFields: ['userId'] });
+        throw new index_js_1.ValidationError("apiKey is required when using user authentication", index_js_2.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: "apiKey", providedFields: ["userId"] });
     }
     // Check for partial partner credentials
     if (config.clientId && !config.clientSecret) {
-        throw new errors_1.ValidationError('clientSecret is required when using partner authentication', types_1.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: 'clientSecret', providedFields: ['clientId'] });
+        throw new index_js_1.ValidationError("clientSecret is required when using partner authentication", index_js_2.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: "clientSecret", providedFields: ["clientId"] });
     }
     if (!config.clientId && config.clientSecret) {
-        throw new errors_1.ValidationError('clientId is required when using partner authentication', types_1.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: 'clientId', providedFields: ['clientSecret'] });
+        throw new index_js_1.ValidationError("clientId is required when using partner authentication", index_js_2.ErrorCodes.VALIDATION_REQUIRED_FIELD, { field: "clientId", providedFields: ["clientSecret"] });
     }
     if (config.apiKey && config.userId) {
-        auth = { type: 'apiKey', apiKey: config.apiKey, userId: config.userId };
+        auth = { type: "apiKey", apiKey: config.apiKey, userId: config.userId };
     }
     else if (config.clientId && config.clientSecret) {
-        auth = { type: 'partner', clientId: config.clientId, clientSecret: config.clientSecret };
+        auth = {
+            type: "partner",
+            clientId: config.clientId,
+            clientSecret: config.clientSecret,
+        };
     }
     else {
-        auth = { type: 'none' };
+        auth = { type: "none" };
     }
     return {
-        baseUrl: config.baseUrl.replace(/\/$/, ''),
+        baseUrl: config.baseUrl.replace(/\/$/, ""),
         auth,
-        timeout: config.timeout ?? constants_1.DEFAULT_TIMEOUT,
-        maxRetries: config.maxRetries ?? constants_1.DEFAULT_MAX_RETRIES,
+        timeout: config.timeout ?? constants_js_1.DEFAULT_TIMEOUT,
+        maxRetries: config.maxRetries ?? constants_js_1.DEFAULT_MAX_RETRIES,
         onRetry: config.onRetry,
     };
 }
@@ -134,20 +138,20 @@ class HttpClient {
      */
     buildHeaders(customHeaders) {
         const headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-            'User-Agent': `@attrove/sdk/${constants_1.SDK_VERSION}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": `@attrove/sdk/${constants_js_1.SDK_VERSION}`,
             ...customHeaders,
         };
         const { auth } = this.config;
-        if (auth.type === 'apiKey') {
-            headers['Authorization'] = `Bearer ${auth.apiKey}`;
-            headers['X-Auth-Type'] = 'api';
-            headers['X-User-Id'] = auth.userId;
+        if (auth.type === "apiKey") {
+            headers["Authorization"] = `Bearer ${auth.apiKey}`;
+            headers["X-Auth-Type"] = "api";
+            headers["X-User-Id"] = auth.userId;
         }
-        else if (auth.type === 'partner') {
-            headers['Authorization'] = `Bearer ${auth.clientSecret}`;
-            headers['X-Auth-Type'] = 'partner';
+        else if (auth.type === "partner") {
+            headers["Authorization"] = `Bearer ${auth.clientSecret}`;
+            headers["X-Auth-Type"] = "partner";
         }
         return headers;
     }
@@ -157,18 +161,18 @@ class HttpClient {
      */
     parseApiError(body, status) {
         // Handle structured error response
-        if (body && typeof body === 'object' && 'error' in body) {
+        if (body && typeof body === "object" && "error" in body) {
             const errorResponse = body;
             const error = errorResponse.error;
-            if (typeof error === 'string') {
-                return (0, errors_1.createErrorFromStatus)(error, status);
+            if (typeof error === "string") {
+                return (0, index_js_1.createErrorFromStatus)(error, status);
             }
-            return (0, errors_1.createErrorFromStatus)(error.message, status, error.code, error.details);
+            return (0, index_js_1.createErrorFromStatus)(error.message, status, error.code, error.details);
         }
         // Handle unknown error format - include response preview for debugging
         let message;
-        if (typeof body === 'string') {
-            message = body || 'Empty error response';
+        if (typeof body === "string") {
+            message = body || "Empty error response";
         }
         else {
             try {
@@ -176,11 +180,13 @@ class HttpClient {
             }
             catch (serializeError) {
                 // Preserve serialization error context for debugging
-                const reason = serializeError instanceof Error ? serializeError.message : 'Unknown reason';
+                const reason = serializeError instanceof Error
+                    ? serializeError.message
+                    : "Unknown reason";
                 message = `Unknown error occurred (response not serializable: ${reason})`;
             }
         }
-        return (0, errors_1.createErrorFromStatus)(message, status);
+        return (0, index_js_1.createErrorFromStatus)(message, status);
     }
     /**
      * Make a request with automatic retries.
@@ -200,7 +206,7 @@ class HttpClient {
      * @throws {ServerError} When server errors occur (5xx)
      */
     async request(path, config = {}, queryParams) {
-        const method = config.method ?? 'GET';
+        const method = config.method ?? "GET";
         const url = this.buildUrl(path, queryParams);
         const headers = this.buildHeaders(config.headers);
         const timeout = config.timeout ?? this.config.timeout;
@@ -214,22 +220,22 @@ class HttpClient {
                     headers,
                     signal: controller.signal,
                 };
-                if (config.body && method !== 'GET') {
+                if (config.body && method !== "GET") {
                     fetchOptions.body = JSON.stringify(config.body);
                 }
                 const response = await fetch(url, fetchOptions);
                 clearTimeout(timeoutId);
                 // Parse response body with explicit JSON error handling
                 let body;
-                const contentType = response.headers.get('content-type');
-                if (contentType?.includes('application/json')) {
+                const contentType = response.headers.get("content-type");
+                if (contentType?.includes("application/json")) {
                     const text = await response.text();
                     try {
                         body = JSON.parse(text);
                     }
                     catch (parseError) {
                         // JSON parse errors are not retryable
-                        throw new errors_1.ServerError(`Server returned invalid JSON: ${parseError instanceof Error ? parseError.message : 'Parse failed'}`, response.status, { responsePreview: text.substring(0, 200) });
+                        throw new index_js_1.ServerError(`Server returned invalid JSON: ${parseError instanceof Error ? parseError.message : "Parse failed"}`, response.status, { responsePreview: text.substring(0, 200) });
                     }
                 }
                 else {
@@ -238,11 +244,11 @@ class HttpClient {
                 // Handle successful response
                 if (response.ok) {
                     // Handle wrapped API responses
-                    if (body && typeof body === 'object' && 'success' in body) {
+                    if (body && typeof body === "object" && "success" in body) {
                         const apiResponse = body;
                         if (apiResponse.success) {
                             // Paginated responses have a `pagination` field - preserve the full structure
-                            if ('pagination' in body) {
+                            if ("pagination" in body) {
                                 return body;
                             }
                             return apiResponse.data;
@@ -255,8 +261,9 @@ class HttpClient {
                 // Handle error response
                 const error = this.parseApiError(body, response.status);
                 // Check if we should retry
-                if (attempt < this.config.maxRetries && constants_1.RETRYABLE_STATUS_SET.has(response.status)) {
-                    const retryAfterSeconds = parseRetryAfter(response.headers.get('retry-after'));
+                if (attempt < this.config.maxRetries &&
+                    constants_js_1.RETRYABLE_STATUS_SET.has(response.status)) {
+                    const retryAfterSeconds = parseRetryAfter(response.headers.get("retry-after"));
                     const delay = calculateRetryDelay(attempt, retryAfterSeconds);
                     // Call retry callback if provided
                     if (this.config.onRetry) {
@@ -277,8 +284,8 @@ class HttpClient {
             }
             catch (err) {
                 // Handle abort/timeout
-                if (err instanceof Error && err.name === 'AbortError') {
-                    const timeoutError = new errors_1.TimeoutError(`Request timed out after ${timeout}ms`);
+                if (err instanceof Error && err.name === "AbortError") {
+                    const timeoutError = new index_js_1.TimeoutError(`Request timed out after ${timeout}ms`);
                     if (attempt < this.config.maxRetries) {
                         const delay = calculateRetryDelay(attempt);
                         if (this.config.onRetry) {
@@ -298,8 +305,8 @@ class HttpClient {
                     throw timeoutError;
                 }
                 // Handle network errors
-                if (err instanceof TypeError && err.message.includes('fetch')) {
-                    const networkError = new errors_1.NetworkError(`Network error: ${err.message}. Check your connection and ensure the API endpoint is accessible.`);
+                if (err instanceof TypeError && err.message.includes("fetch")) {
+                    const networkError = new index_js_1.NetworkError(`Network error: ${err.message}. Check your connection and ensure the API endpoint is accessible.`);
                     if (attempt < this.config.maxRetries) {
                         const delay = calculateRetryDelay(attempt);
                         if (this.config.onRetry) {
@@ -319,7 +326,7 @@ class HttpClient {
                     throw networkError;
                 }
                 // Re-throw AttroveErrors (including ServerError from JSON parse)
-                if (err instanceof errors_1.AttroveError) {
+                if (err instanceof index_js_1.AttroveError) {
                     throw err;
                 }
                 // Handle unexpected errors - preserve as much context as possible
@@ -329,10 +336,13 @@ class HttpClient {
                     originalErrorMessage: originalError.message,
                 };
                 if (originalError.stack) {
-                    errorDetails.originalStack = originalError.stack.split('\n').slice(0, 5).join('\n');
+                    errorDetails.originalStack = originalError.stack
+                        .split("\n")
+                        .slice(0, 5)
+                        .join("\n");
                 }
                 // Wrap in ServerError to indicate this was an unexpected failure
-                const wrappedError = new errors_1.ServerError(`Unexpected error during request: ${originalError.message}`, undefined, // No status code for unexpected errors
+                const wrappedError = new index_js_1.ServerError(`Unexpected error during request: ${originalError.message}`, undefined, // No status code for unexpected errors
                 errorDetails);
                 lastError = wrappedError;
                 if (attempt < this.config.maxRetries) {
@@ -354,7 +364,10 @@ class HttpClient {
             }
         }
         // Should not reach here, but just in case - use ServerError for consistency
-        throw lastError || new errors_1.ServerError('Max retries exceeded', undefined, { maxRetries: this.config.maxRetries });
+        throw (lastError ||
+            new index_js_1.ServerError("Max retries exceeded", undefined, {
+                maxRetries: this.config.maxRetries,
+            }));
     }
     /**
      * Make a GET request.
@@ -366,7 +379,7 @@ class HttpClient {
      * @throws {NetworkError} When network errors occur
      */
     get(path, params, config) {
-        return this.request(path, { ...config, method: 'GET' }, params);
+        return this.request(path, { ...config, method: "GET" }, params);
     }
     /**
      * Make a POST request.
@@ -377,7 +390,7 @@ class HttpClient {
      * @throws {NetworkError} When network errors occur
      */
     post(path, body, config) {
-        return this.request(path, { ...config, method: 'POST', body });
+        return this.request(path, { ...config, method: "POST", body });
     }
     /**
      * Make a PUT request.
@@ -388,7 +401,7 @@ class HttpClient {
      * @throws {NetworkError} When network errors occur
      */
     put(path, body, config) {
-        return this.request(path, { ...config, method: 'PUT', body });
+        return this.request(path, { ...config, method: "PUT", body });
     }
     /**
      * Make a PATCH request.
@@ -399,7 +412,7 @@ class HttpClient {
      * @throws {NetworkError} When network errors occur
      */
     patch(path, body, config) {
-        return this.request(path, { ...config, method: 'PATCH', body });
+        return this.request(path, { ...config, method: "PATCH", body });
     }
     /**
      * Make a DELETE request.
@@ -410,8 +423,7 @@ class HttpClient {
      * @throws {NetworkError} When network errors occur
      */
     delete(path, config) {
-        return this.request(path, { ...config, method: 'DELETE' });
+        return this.request(path, { ...config, method: "DELETE" });
     }
 }
 exports.HttpClient = HttpClient;
-//# sourceMappingURL=fetch.js.map

package/cjs/{src/utils → utils}/index.js

@@ -4,9 +4,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMessageId = exports.StreamingClient = exports.HttpClient = void 0;
-var fetch_1 = require("./fetch");
-Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return fetch_1.HttpClient; } });
-var streaming_1 = require("./streaming");
-Object.defineProperty(exports, "StreamingClient", { enumerable: true, get: function () { return streaming_1.StreamingClient; } });
-Object.defineProperty(exports, "generateMessageId", { enumerable: true, get: function () { return streaming_1.generateMessageId; } });
-//# sourceMappingURL=index.js.map
+var fetch_js_1 = require("./fetch.js");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return fetch_js_1.HttpClient; } });
+var streaming_js_1 = require("./streaming.js");
+Object.defineProperty(exports, "StreamingClient", { enumerable: true, get: function () { return streaming_js_1.StreamingClient; } });
+Object.defineProperty(exports, "generateMessageId", { enumerable: true, get: function () { return streaming_js_1.generateMessageId; } });

package/cjs/{src/utils → utils}/streaming.js

@@ -13,10 +13,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateMessageId = exports.StreamingClient = void 0;
-const types_1 = require("../types");
-const errors_1 = require("../errors");
-const types_2 = require("../types");
-const constants_1 = require("../constants");
+const index_js_1 = require("../types/index.js");
+const index_js_2 = require("../errors/index.js");
+const index_js_3 = require("../types/index.js");
+const constants_js_1 = require("../constants.js");
 /**
  * Streaming query client for WebSocket-based LLM responses.
  *
@@ -44,7 +44,7 @@ class StreamingClient {
         this.ws = null;
         this.currentMessageId = null;
         // Convert HTTP URL to WebSocket URL
-        const wsBaseUrl = baseUrl.replace(/^http/, 'ws');
+        const wsBaseUrl = baseUrl.replace(/^http/, "ws");
         this.wsUrl = `${wsBaseUrl}/ws/llm-stream`;
         this.token = token;
     }
@@ -54,17 +54,17 @@ class StreamingClient {
      * @throws {TimeoutError} If connection times out
      * @throws {NetworkError} If connection fails
      */
-    async connect(timeout = constants_1.DEFAULT_TIMEOUT) {
+    async connect(timeout = constants_js_1.DEFAULT_TIMEOUT) {
         return new Promise((resolve, reject) => {
             const timeoutId = setTimeout(() => {
-                reject(new errors_1.TimeoutError(`WebSocket connection timed out after ${timeout}ms`));
+                reject(new index_js_2.TimeoutError(`WebSocket connection timed out after ${timeout}ms`));
             }, timeout);
             try {
                 // Note: Token is passed as query parameter because WebSocket API
                 // doesn't support custom headers in browsers. This is a common pattern
                 // but means the token may appear in server logs.
                 const url = new URL(this.wsUrl);
-                url.searchParams.set('token', this.token);
+                url.searchParams.set("token", this.token);
                 const ws = new WebSocket(url.toString());
                 ws.onopen = () => {
                     clearTimeout(timeoutId);
@@ -72,19 +72,19 @@ class StreamingClient {
                 };
                 ws.onerror = () => {
                     clearTimeout(timeoutId);
-                    reject(new errors_1.NetworkError(`WebSocket connection to ${this.wsUrl} failed. Check your network connection and ensure the API endpoint is accessible.`));
+                    reject(new index_js_2.NetworkError(`WebSocket connection to ${this.wsUrl} failed. Check your network connection and ensure the API endpoint is accessible.`));
                 };
                 ws.onclose = (event) => {
                     if (event.code !== 1000) {
                         clearTimeout(timeoutId);
-                        const reason = (0, constants_1.getWsCloseReason)(event.code);
-                        reject(new errors_1.NetworkError(`WebSocket closed during connection (code ${event.code}: ${reason}). This may indicate a server issue or network problem.`));
+                        const reason = (0, constants_js_1.getWsCloseReason)(event.code);
+                        reject(new index_js_2.NetworkError(`WebSocket closed during connection (code ${event.code}: ${reason}). This may indicate a server issue or network problem.`));
                     }
                 };
             }
             catch (err) {
                 clearTimeout(timeoutId);
-                reject(new errors_1.NetworkError(`Failed to create WebSocket: ${err instanceof Error ? err.message : String(err)}`));
+                reject(new index_js_2.NetworkError(`Failed to create WebSocket: ${err instanceof Error ? err.message : String(err)}`));
             }
         });
     }
@@ -103,10 +103,10 @@ class StreamingClient {
      * @throws {AttroveError} If the server returns an error
      */
     async stream(query, messageId, history, queryOptions = {}, streamOptions = {}) {
-        const { onChunk, onState, onStart, onError, onEnd, onWarning, signal, timeout = constants_1.DEFAULT_TIMEOUT } = streamOptions;
+        const { onChunk, onState, onStart, onError, onEnd, onWarning, signal, timeout = constants_js_1.DEFAULT_TIMEOUT, } = streamOptions;
         // Store warning callback for use in cancel() and cleanup()
         this.onWarning = onWarning;
-        let answer = '';
+        let answer = "";
         let usedMessageIds = [];
         let cancelled = false;
         let completed = false;
@@ -115,7 +115,7 @@ class StreamingClient {
         this.currentMessageId = messageId;
         return new Promise((resolve, reject) => {
             if (!this.ws) {
-                reject(new errors_1.NetworkError('WebSocket not connected'));
+                reject(new index_js_2.NetworkError("WebSocket not connected"));
                 return;
             }
             const ws = this.ws;
@@ -125,7 +125,7 @@ class StreamingClient {
             const cleanupAndFinish = () => {
                 completed = true;
                 if (signal && abortHandler) {
-                    signal.removeEventListener('abort', abortHandler);
+                    signal.removeEventListener("abort", abortHandler);
                 }
                 this.cleanup();
             };
@@ -137,7 +137,7 @@ class StreamingClient {
                         cancelled = true;
                     }
                 };
-                signal.addEventListener('abort', abortHandler);
+                signal.addEventListener("abort", abortHandler);
                 // Check if already aborted
                 if (signal.aborted) {
                     this.cancel();
@@ -146,21 +146,22 @@ class StreamingClient {
             }
             // Send the query to the server after connection is established
             const queryPayload = {
-                type: 'query',
+                type: "query",
                 message_id: messageId,
                 query,
-                client_timezone: queryOptions.timezone || Intl.DateTimeFormat().resolvedOptions().timeZone,
+                client_timezone: queryOptions.timezone ||
+                    Intl.DateTimeFormat().resolvedOptions().timeZone,
                 history: history.length > 0 ? history : undefined,
                 integration_ids: queryOptions.integrationIds,
                 conversation_ids: queryOptions.conversationIds,
                 allow_bot_messages: queryOptions.allowBotMessages,
-                expand: queryOptions.includeSources ? 'sources' : undefined,
+                expand: queryOptions.includeSources ? "sources" : undefined,
             };
             try {
                 ws.send(JSON.stringify(queryPayload));
             }
             catch (err) {
-                const error = new errors_1.NetworkError(`Failed to send query to server: ${err instanceof Error ? err.message : String(err)}`);
+                const error = new index_js_2.NetworkError(`Failed to send query to server: ${err instanceof Error ? err.message : String(err)}`);
                 onError?.(error);
                 cleanupAndFinish();
                 reject(error);
@@ -173,15 +174,21 @@ class StreamingClient {
                     parsed = JSON.parse(event.data);
                 }
                 catch (parseErr) {
-                    const error = new errors_1.AttroveError(`Failed to parse stream message: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`, types_2.ErrorCodes.INTERNAL_ERROR, undefined, { category: 'parse', rawDataPreview: String(event.data).substring(0, 200) });
+                    const error = new index_js_2.AttroveError(`Failed to parse stream message: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`, index_js_3.ErrorCodes.INTERNAL_ERROR, undefined, {
+                        category: "parse",
+                        rawDataPreview: String(event.data).substring(0, 200),
+                    });
                     onError?.(error);
                     cleanupAndFinish();
                     reject(error);
                     return;
                 }
                 // Validate the frame structure at runtime
-                if (!(0, types_1.isValidStreamFrame)(parsed)) {
-                    const error = new errors_1.AttroveError('Received invalid stream frame format from server', types_2.ErrorCodes.INTERNAL_ERROR, undefined, { category: 'parse', rawDataPreview: JSON.stringify(parsed).substring(0, 200) });
+                if (!(0, index_js_1.isValidStreamFrame)(parsed)) {
+                    const error = new index_js_2.AttroveError("Received invalid stream frame format from server", index_js_3.ErrorCodes.INTERNAL_ERROR, undefined, {
+                        category: "parse",
+                        rawDataPreview: JSON.stringify(parsed).substring(0, 200),
+                    });
                     onError?.(error);
                     cleanupAndFinish();
                     reject(error);
@@ -196,7 +203,7 @@ class StreamingClient {
                         frameType: frame.type,
                     };
                     if (onWarning) {
-                        onWarning('Received message with mismatched message_id, ignoring', warningContext);
+                        onWarning("Received message with mismatched message_id, ignoring", warningContext);
                     }
                     else {
                         // prettier-ignore
@@ -206,28 +213,28 @@ class StreamingClient {
                 }
                 // Process the parsed frame - callback errors will propagate naturally
                 switch (frame.type) {
-                    case 'stream_start':
+                    case "stream_start":
                         onStart?.();
                         break;
-                    case 'state':
+                    case "state":
                         onState?.(frame.state);
                         break;
-                    case 'chunk':
+                    case "chunk":
                         answer += frame.content;
                         onChunk?.(frame.content);
                         break;
-                    case 'message_ids':
+                    case "message_ids":
                         usedMessageIds = frame.used_message_ids;
                         break;
-                    case 'error': {
-                        const error = new errors_1.AttroveError(frame.error, types_2.ErrorCodes.INTERNAL_ERROR);
+                    case "error": {
+                        const error = new index_js_2.AttroveError(frame.error, index_js_3.ErrorCodes.INTERNAL_ERROR);
                         onError?.(error);
                         cleanupAndFinish();
                         reject(error);
                         break;
                     }
-                    case 'end': {
-                        cancelled = frame.reason === 'cancelled';
+                    case "end": {
+                        cancelled = frame.reason === "cancelled";
                         if (frame.used_message_ids) {
                             usedMessageIds = frame.used_message_ids;
                         }
@@ -235,7 +242,7 @@ class StreamingClient {
                         // Build updated history
                         const updatedHistory = [
                             ...history,
-                            { role: 'assistant', content: answer },
+                            { role: "assistant", content: answer },
                         ];
                         cleanupAndFinish();
                         resolve({
@@ -250,7 +257,7 @@ class StreamingClient {
             };
             ws.onerror = () => {
                 if (!completed) {
-                    const error = new errors_1.NetworkError(`WebSocket error during streaming. The connection was interrupted. You may need to retry the query.`);
+                    const error = new index_js_2.NetworkError(`WebSocket error during streaming. The connection was interrupted. You may need to retry the query.`);
                     onError?.(error);
                     cleanupAndFinish();
                     reject(error);
@@ -258,8 +265,8 @@ class StreamingClient {
             };
             ws.onclose = (event) => {
                 if (!completed && event.code !== 1000) {
-                    const reason = (0, constants_1.getWsCloseReason)(event.code);
-                    const error = new errors_1.NetworkError(`WebSocket closed unexpectedly (code ${event.code}: ${reason}). The stream may need to be retried.`);
+                    const reason = (0, constants_js_1.getWsCloseReason)(event.code);
+                    const error = new index_js_2.NetworkError(`WebSocket closed unexpectedly (code ${event.code}: ${reason}). The stream may need to be retried.`);
                     onError?.(error);
                     cleanupAndFinish();
                     reject(error);
@@ -291,27 +298,33 @@ class StreamingClient {
      */
     cancel() {
         if (!this.ws || !this.currentMessageId) {
-            return { success: false, reason: 'no_active_stream' };
+            return { success: false, reason: "no_active_stream" };
         }
         try {
             this.ws.send(JSON.stringify({
-                type: 'stop',
+                type: "stop",
                 message_id: this.currentMessageId,
             }));
-            return { success: true, reason: 'sent' };
+            return { success: true, reason: "sent" };
         }
         catch (err) {
             // Cancellation is best-effort - the WebSocket may already be closed
             const errorMessage = err instanceof Error ? err.message : String(err);
-            const context = { messageId: this.currentMessageId, wsReadyState: this.ws?.readyState };
+            const context = {
+                messageId: this.currentMessageId,
+                wsReadyState: this.ws?.readyState,
+            };
             if (this.onWarning) {
-                this.onWarning('Failed to send cancel message', { error: errorMessage, ...context });
+                this.onWarning("Failed to send cancel message", {
+                    error: errorMessage,
+                    ...context,
+                });
             }
             else {
                 // prettier-ignore
                 console.warn('[AttroveSDK] Failed to send cancel message:', errorMessage, context);
             }
-            return { success: false, reason: 'send_failed', error: errorMessage };
+            return { success: false, reason: "send_failed", error: errorMessage };
         }
     }
     /**
@@ -330,7 +343,9 @@ class StreamingClient {
                 // Cleanup is best-effort - the WebSocket may already be closed
                 const errorMessage = err instanceof Error ? err.message : String(err);
                 if (this.onWarning) {
-                    this.onWarning('Failed to close WebSocket cleanly', { error: errorMessage });
+                    this.onWarning("Failed to close WebSocket cleanly", {
+                        error: errorMessage,
+                    });
                 }
                 else {
                     // prettier-ignore
@@ -365,4 +380,3 @@ function generateMessageId() {
     return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
 }
 exports.generateMessageId = generateMessageId;
-//# sourceMappingURL=streaming.js.map

package/cjs/{src/version.js → version.js}

@@ -7,15 +7,15 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetVersionCache = exports.getVersion = void 0;
-const constants_1 = require("./constants");
+const constants_js_1 = require("./constants.js");
 /**
  * Get the SDK version.
  *
  * Returns the SDK version string from the hardcoded constant.
- * This value should be kept in sync with package.json during releases.
+ * This value is automatically synced with package.json during releases.
  */
 function getVersion() {
-    return constants_1.SDK_VERSION;
+    return constants_js_1.SDK_VERSION;
 }
 exports.getVersion = getVersion;
 /**
@@ -28,4 +28,3 @@ function resetVersionCache() {
     // No-op - version is now a static constant
 }
 exports.resetVersionCache = resetVersionCache;
-//# sourceMappingURL=version.js.map

package/esm/__mocks__/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../../packages/sdk/src/__mocks__/version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED,wBAAgB,iBAAiB,IAAI,IAAI,CAExC"}

package/esm/{src/__mocks__ → __mocks__}/version.js

@@ -4,7 +4,7 @@
  * This avoids the import.meta.url ESM issue when running tests with ts-jest.
  */
 export function getVersion() {
-    return '1.0.0-test';
+    return "1.0.0-test";
 }
 export function resetVersionCache() {
     // No-op in mock

package/esm/__mocks__/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../../../../packages/sdk/src/__mocks__/version.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,UAAU,UAAU;IACxB,OAAO,YAAY,CAAC;AACtB,CAAC;AAED,MAAM,UAAU,iBAAiB;IAC/B,gBAAgB;AAClB,CAAC"}