@dotbots-boutique/auth-sdk 1.0.15 → 1.0.18

package/README.md

@@ -190,6 +190,81 @@ Possible `PAYMENT_FAILED` messages: `INSUFFICIENT_BALANCE`, `BUDGET_EXCEEDED`, `
 
 ---
 
+## AI Gateway
+
+The SDK provides access to the platform AI gateway. The developer never needs to know which provider or model is used — the platform handles routing, billing and rate limiting.
+
+### Non-streaming
+
+```typescript
+import type { AiResponse } from '@dotbots-boutique/auth-sdk';
+
+const response: AiResponse = await auth.ai('generate-text', {
+  messages: [{ role: 'user', content: 'Summarise this document' }],
+  maxTokens: 1000,
+});
+
+console.log(response.content);
+console.log(response.usage.totalTokens);
+console.log(response.cost.eur);
+```
+
+### Streaming
+
+```typescript
+let fullText = '';
+
+await auth.aiStream('generate-text', {
+  messages: [{ role: 'user', content: 'Write a poem' }],
+}, (delta) => {
+  fullText += delta;
+  updateUI(fullText);
+}, (response) => {
+  console.log('Done — model:', response.model, 'tokens:', response.usage.totalTokens);
+});
+```
+
+### Tool calling
+
+```typescript
+const response = await auth.ai('agent', {
+  messages: [{ role: 'user', content: 'What is the weather in Brussels?' }],
+  tools: [{
+    name: 'get_weather',
+    description: 'Get current weather for a city',
+    parameters: { type: 'object', properties: { city: { type: 'string' } }, required: ['city'] },
+  }],
+});
+
+if (response.toolCalls?.length) {
+  console.log(response.toolCalls[0].name, response.toolCalls[0].input);
+}
+```
+
+### Error handling
+
+```typescript
+try {
+  const response = await auth.ai('generate-text', { messages });
+} catch (error) {
+  if (error instanceof DotBotsAuthError) {
+    switch (error.code) {
+      case 'AI_INSUFFICIENT_BALANCE':
+        // show top-up prompt
+        break;
+      case 'AI_FEATURE_NOT_FOUND':
+        // feature not configured
+        break;
+      case 'AI_CALL_FAILED':
+        // provider error
+        break;
+    }
+  }
+}
+```
+
+---
+
 ## Checking permissions
 
 ```typescript
@@ -262,6 +337,11 @@ try {
 | `NOT_INITIALIZED` | `initialize()` has not been called yet | Yes |
 | `PROXY_UNAVAILABLE` | Proxy config could not be fetched | No — falls back to direct API |
 | `PAYMENT_FAILED` | Payment was rejected (402) — see `message` for reason | No |
+| `AI_FEATURE_NOT_FOUND` | AI feature code not configured in platform | No |
+| `AI_PROVIDER_NOT_CONFIGURED` | API key not set for AI provider | No |
+| `AI_INSUFFICIENT_BALANCE` | Organisation balance is 0 | No |
+| `AI_CALL_FAILED` | AI provider returned an error | No |
+| `AI_STREAM_ERROR` | Streaming connection failed | No |
 
 ---
 
@@ -342,6 +422,14 @@ Authenticated fetch wrapper. Routes through the proxy when available, falls back
 
 Charges a feature usage. Calls `POST {proxyUrl}/payments/charge`. On success, sends a `DOTBOTS_CHARGE` postMessage to the parent window (iframe only) and emits the `charged` event. Throws `PAYMENT_FAILED` on 402 with a message indicating the reason (`INSUFFICIENT_BALANCE`, `BUDGET_EXCEEDED`, `FEATURE_NOT_FOUND`, `PAYMENT_REJECTED`).
 
+#### `ai(feature: string, request: AiRequest): Promise<AiResponse>`
+
+Non-streaming AI call via the platform AI gateway. Calls `POST {proxyUrl}/ai/call`. Returns the full response with content, model, usage and cost.
+
+#### `aiStream(feature: string, request: AiRequest, onDelta: (delta: string) => void, onDone?: (response: AiResponse) => void): Promise<void>`
+
+Streaming AI call. `onDelta` fires for each text chunk, `onDone` fires with usage/cost metadata when the stream completes.
+
 #### `logout(): Promise<void>`
 
 Logs out the user. Revokes tokens on `apiUrl`, clears state, and redirects (standalone) or notifies the parent (iframe).
@@ -367,6 +455,8 @@ const {
   hasRole,    // (role: string) => boolean
   fetch,      // auth.fetch proxied
   charge,     // auth.charge proxied
+  ai,         // auth.ai proxied
+  aiStream,   // auth.aiStream proxied
   logout,     // auth.logout proxied
 } = useDotBotsAuth();
 ```
@@ -462,7 +552,7 @@ To report a security vulnerability, please email [security@dotbots.ai](mailto:se
 
 ```typescript
 import { DotBotsAuth, DotBotsAuthError } from '@dotbots-boutique/auth-sdk';
-import type { DotBotsUser, DotBotsConfig, DotBotsAuthEvent, DotBotsProxyConfig } from '@dotbots-boutique/auth-sdk';
+import type { DotBotsUser, DotBotsConfig, DotBotsAuthEvent, DotBotsProxyConfig, AiRequest, AiResponse, AiMessage, AiTool, AiToolCall } from '@dotbots-boutique/auth-sdk';
 import { DotBotsAuthProvider, useDotBotsAuth } from '@dotbots-boutique/auth-sdk/react';
 ```
 

package/dist/cjs/index.js

@@ -297,7 +297,8 @@ class DotBotsAuth {
             this.cachedUser = null;
             this.tokenManager.clear();
             await this.tokenManager.exchangeCode(event.data.code);
-            this.emit('userChanged');
+            const newUser = await this.getUser();
+            this.emit('userChanged', newUser);
         });
     }
     async getUser() {
@@ -381,6 +382,100 @@ class DotBotsAuth {
         this.emit('charged');
         return data;
     }
+    async ai(feature, request) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] ai() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: false,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] ai() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (response.status === 400) {
+            const body = await response.json();
+            console.error(`[DotBotsAuth] ai() failed — 400: ${body.error}`);
+            throw new DotBotsAuthError(body.error || 'AI_FEATURE_NOT_FOUND', body.message ?? 'AI request failed');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] ai() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI call failed: ${response.status}`);
+        }
+        const data = await response.json();
+        console.warn(`[DotBotsAuth] ai() success — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+        return data;
+    }
+    async aiStream(feature, request, onDelta, onDone) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] aiStream() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: true,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] aiStream() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] aiStream() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI stream failed: ${response.status}`);
+        }
+        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) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = JSON.parse(line.slice(6));
+                    if (data.type === 'text') {
+                        onDelta(data.delta);
+                    }
+                    else if (data.type === 'done') {
+                        const finalResponse = {
+                            content: '',
+                            model: data.model,
+                            provider: data.provider,
+                            usage: data.usage,
+                            cost: data.cost,
+                            transactionId: data.transactionId,
+                            toolCalls: data.toolCalls,
+                        };
+                        console.warn(`[DotBotsAuth] aiStream() done — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+                        onDone?.(finalResponse);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[DotBotsAuth] aiStream() error:', err instanceof Error ? err.message : err);
+            throw new DotBotsAuthError('AI_STREAM_ERROR', 'Streaming connection failed', err instanceof Error ? err : undefined);
+        }
+    }
     async logout() {
         this.assertInitialized();
         await this.tokenManager.revoke();
@@ -457,12 +552,12 @@ class DotBotsAuth {
             throw new DotBotsAuthError('NOT_INITIALIZED', 'Call initialize() before using the SDK');
         }
     }
-    emit(event) {
+    emit(event, data) {
         const handlers = this.listeners.get(event);
         if (handlers) {
             for (const handler of handlers) {
                 try {
-                    handler();
+                    handler(data);
                 }
                 catch {
                     // Don't let listener errors break the SDK
@@ -471,7 +566,7 @@ class DotBotsAuth {
         }
     }
 }
-DotBotsAuth.SDK_VERSION = '1.0.15';
+DotBotsAuth.SDK_VERSION = '1.0.18';
 
 exports.DotBotsAuth = DotBotsAuth;
 exports.DotBotsAuthError = DotBotsAuthError;

package/dist/cjs/react/index.js

@@ -31,6 +31,15 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
             cancelled = true;
         };
     }, [auth]);
+    react.useEffect(() => {
+        const handler = (newUser) => {
+            setUser(newUser);
+        };
+        auth.on('userChanged', handler);
+        return () => {
+            auth.off('userChanged', handler);
+        };
+    }, [auth]);
     if (isLoading) {
         return jsxRuntime.jsx(jsxRuntime.Fragment, { children: loadingComponent ?? jsxRuntime.jsx("div", { children: "Loading..." }) });
     }
@@ -50,6 +59,8 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
         hasRole: (role) => auth.hasRole(role),
         fetch: (url, options) => auth.fetch(url, options),
         charge: (featureCode, paidBy, quantity) => auth.charge(featureCode, paidBy, quantity),
+        ai: (feature, request) => auth.ai(feature, request),
+        aiStream: (feature, request, onDelta, onDone) => auth.aiStream(feature, request, onDelta, onDone),
         logout: () => auth.logout(),
     };
     return (jsxRuntime.jsx(DotBotsAuthContext.Provider, { value: value, children: children }));

package/dist/esm/index.js

@@ -295,7 +295,8 @@ class DotBotsAuth {
             this.cachedUser = null;
             this.tokenManager.clear();
             await this.tokenManager.exchangeCode(event.data.code);
-            this.emit('userChanged');
+            const newUser = await this.getUser();
+            this.emit('userChanged', newUser);
         });
     }
     async getUser() {
@@ -379,6 +380,100 @@ class DotBotsAuth {
         this.emit('charged');
         return data;
     }
+    async ai(feature, request) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] ai() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: false,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] ai() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (response.status === 400) {
+            const body = await response.json();
+            console.error(`[DotBotsAuth] ai() failed — 400: ${body.error}`);
+            throw new DotBotsAuthError(body.error || 'AI_FEATURE_NOT_FOUND', body.message ?? 'AI request failed');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] ai() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI call failed: ${response.status}`);
+        }
+        const data = await response.json();
+        console.warn(`[DotBotsAuth] ai() success — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+        return data;
+    }
+    async aiStream(feature, request, onDelta, onDone) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] aiStream() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: true,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] aiStream() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] aiStream() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI stream failed: ${response.status}`);
+        }
+        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) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = JSON.parse(line.slice(6));
+                    if (data.type === 'text') {
+                        onDelta(data.delta);
+                    }
+                    else if (data.type === 'done') {
+                        const finalResponse = {
+                            content: '',
+                            model: data.model,
+                            provider: data.provider,
+                            usage: data.usage,
+                            cost: data.cost,
+                            transactionId: data.transactionId,
+                            toolCalls: data.toolCalls,
+                        };
+                        console.warn(`[DotBotsAuth] aiStream() done — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+                        onDone?.(finalResponse);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[DotBotsAuth] aiStream() error:', err instanceof Error ? err.message : err);
+            throw new DotBotsAuthError('AI_STREAM_ERROR', 'Streaming connection failed', err instanceof Error ? err : undefined);
+        }
+    }
     async logout() {
         this.assertInitialized();
         await this.tokenManager.revoke();
@@ -455,12 +550,12 @@ class DotBotsAuth {
             throw new DotBotsAuthError('NOT_INITIALIZED', 'Call initialize() before using the SDK');
         }
     }
-    emit(event) {
+    emit(event, data) {
         const handlers = this.listeners.get(event);
         if (handlers) {
             for (const handler of handlers) {
                 try {
-                    handler();
+                    handler(data);
                 }
                 catch {
                     // Don't let listener errors break the SDK
@@ -469,6 +564,6 @@ class DotBotsAuth {
         }
     }
 }
-DotBotsAuth.SDK_VERSION = '1.0.15';
+DotBotsAuth.SDK_VERSION = '1.0.18';
 
 export { DotBotsAuth, DotBotsAuthError };

package/dist/esm/react/index.js

@@ -29,6 +29,15 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
             cancelled = true;
         };
     }, [auth]);
+    useEffect(() => {
+        const handler = (newUser) => {
+            setUser(newUser);
+        };
+        auth.on('userChanged', handler);
+        return () => {
+            auth.off('userChanged', handler);
+        };
+    }, [auth]);
     if (isLoading) {
         return jsx(Fragment, { children: loadingComponent ?? jsx("div", { children: "Loading..." }) });
     }
@@ -48,6 +57,8 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
         hasRole: (role) => auth.hasRole(role),
         fetch: (url, options) => auth.fetch(url, options),
         charge: (featureCode, paidBy, quantity) => auth.charge(featureCode, paidBy, quantity),
+        ai: (feature, request) => auth.ai(feature, request),
+        aiStream: (feature, request, onDelta, onDone) => auth.aiStream(feature, request, onDelta, onDone),
         logout: () => auth.logout(),
     };
     return (jsx(DotBotsAuthContext.Provider, { value: value, children: children }));

package/dist/types/DotBotsAuth.d.ts

@@ -1,4 +1,4 @@
-import type { DotBotsConfig, DotBotsUser, DotBotsAuthEvent, DotBotsProxyConfig } from './types.js';
+import type { DotBotsConfig, DotBotsUser, DotBotsAuthEvent, DotBotsProxyConfig, AiRequest, AiResponse } from './types.js';
 export declare class DotBotsAuth {
     private readonly config;
     private readonly environment;
@@ -10,7 +10,7 @@ export declare class DotBotsAuth {
     private cachedUser;
     private initialized;
     private initializePromise;
-    static readonly SDK_VERSION = "1.0.15";
+    static readonly SDK_VERSION = "1.0.18";
     constructor(config: DotBotsConfig);
     initialize(): Promise<void>;
     private _doInitialize;
@@ -23,6 +23,8 @@ export declare class DotBotsAuth {
     charge(featureCode: string, paidBy: 'org' | 'app', quantity?: number): Promise<{
         transactionId: string;
     }>;
+    ai(feature: string, request: AiRequest): Promise<AiResponse>;
+    aiStream(feature: string, request: AiRequest, onDelta: (delta: string) => void, onDone?: (response: AiResponse) => void): Promise<void>;
     logout(): Promise<void>;
     on(event: DotBotsAuthEvent, handler: Function): void;
     off(event: DotBotsAuthEvent, handler: Function): void;

package/dist/types/index.d.ts

@@ -1,3 +1,3 @@
 export { DotBotsAuth } from './DotBotsAuth.js';
 export { DotBotsAuthError } from './DotBotsAuthError.js';
-export type { DotBotsConfig, DotBotsUser, DotBotsAuthEvent, DotBotsAuthErrorCode, DotBotsProxyConfig, ProxyFeature, DotBotsEnvironment, } from './types.js';
+export type { DotBotsConfig, DotBotsUser, DotBotsAuthEvent, DotBotsAuthErrorCode, DotBotsProxyConfig, ProxyFeature, DotBotsEnvironment, AiMessage, AiContentBlock, AiTool, AiRequest, AiResponse, AiToolCall, } from './types.js';

package/dist/types/index.js

@@ -295,7 +295,8 @@ class DotBotsAuth {
             this.cachedUser = null;
             this.tokenManager.clear();
             await this.tokenManager.exchangeCode(event.data.code);
-            this.emit('userChanged');
+            const newUser = await this.getUser();
+            this.emit('userChanged', newUser);
         });
     }
     async getUser() {
@@ -379,6 +380,100 @@ class DotBotsAuth {
         this.emit('charged');
         return data;
     }
+    async ai(feature, request) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] ai() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: false,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] ai() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (response.status === 400) {
+            const body = await response.json();
+            console.error(`[DotBotsAuth] ai() failed — 400: ${body.error}`);
+            throw new DotBotsAuthError(body.error || 'AI_FEATURE_NOT_FOUND', body.message ?? 'AI request failed');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] ai() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI call failed: ${response.status}`);
+        }
+        const data = await response.json();
+        console.warn(`[DotBotsAuth] ai() success — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+        return data;
+    }
+    async aiStream(feature, request, onDelta, onDone) {
+        this.assertInitialized();
+        const baseUrl = this.proxyConfigManager.getBaseUrl();
+        console.warn(`[DotBotsAuth] aiStream() — feature: ${feature}, messages: ${request.messages.length}`);
+        const response = await this.buildRequest(`${baseUrl}/ai/call`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                feature,
+                messages: request.messages,
+                tools: request.tools,
+                stream: true,
+                maxTokens: request.maxTokens,
+            }),
+        });
+        if (response.status === 402) {
+            console.error('[DotBotsAuth] aiStream() failed — 402: insufficient balance');
+            throw new DotBotsAuthError('AI_INSUFFICIENT_BALANCE', 'Insufficient balance for AI call');
+        }
+        if (!response.ok) {
+            console.error(`[DotBotsAuth] aiStream() failed — HTTP ${response.status}`);
+            throw new DotBotsAuthError('AI_CALL_FAILED', `AI stream failed: ${response.status}`);
+        }
+        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) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = JSON.parse(line.slice(6));
+                    if (data.type === 'text') {
+                        onDelta(data.delta);
+                    }
+                    else if (data.type === 'done') {
+                        const finalResponse = {
+                            content: '',
+                            model: data.model,
+                            provider: data.provider,
+                            usage: data.usage,
+                            cost: data.cost,
+                            transactionId: data.transactionId,
+                            toolCalls: data.toolCalls,
+                        };
+                        console.warn(`[DotBotsAuth] aiStream() done — model: ${data.model}, tokens: ${data.usage.totalTokens}, transactionId: ${data.transactionId}`);
+                        onDone?.(finalResponse);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[DotBotsAuth] aiStream() error:', err instanceof Error ? err.message : err);
+            throw new DotBotsAuthError('AI_STREAM_ERROR', 'Streaming connection failed', err instanceof Error ? err : undefined);
+        }
+    }
     async logout() {
         this.assertInitialized();
         await this.tokenManager.revoke();
@@ -455,12 +550,12 @@ class DotBotsAuth {
             throw new DotBotsAuthError('NOT_INITIALIZED', 'Call initialize() before using the SDK');
         }
     }
-    emit(event) {
+    emit(event, data) {
         const handlers = this.listeners.get(event);
         if (handlers) {
             for (const handler of handlers) {
                 try {
-                    handler();
+                    handler(data);
                 }
                 catch {
                     // Don't let listener errors break the SDK
@@ -469,6 +564,6 @@ class DotBotsAuth {
         }
     }
 }
-DotBotsAuth.SDK_VERSION = '1.0.15';
+DotBotsAuth.SDK_VERSION = '1.0.18';
 
 export { DotBotsAuth, DotBotsAuthError };

package/dist/types/react/DotBotsAuthProvider.d.ts

@@ -1,6 +1,6 @@
 import { type ReactNode } from 'react';
 import type { DotBotsAuth } from '../DotBotsAuth.js';
-import type { DotBotsUser } from '../types.js';
+import type { DotBotsUser, AiRequest, AiResponse } from '../types.js';
 import type { DotBotsAuthError } from '../DotBotsAuthError.js';
 export interface DotBotsAuthContextValue {
     user: DotBotsUser | null;
@@ -14,6 +14,8 @@ export interface DotBotsAuthContextValue {
     charge: (featureCode: string, paidBy: 'org' | 'app', quantity?: number) => Promise<{
         transactionId: string;
     }>;
+    ai: (feature: string, request: AiRequest) => Promise<AiResponse>;
+    aiStream: (feature: string, request: AiRequest, onDelta: (delta: string) => void, onDone?: (response: AiResponse) => void) => Promise<void>;
     logout: () => Promise<void>;
 }
 export declare const DotBotsAuthContext: import("react").Context<DotBotsAuthContextValue | null>;

package/dist/types/react/index.js

@@ -29,6 +29,15 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
             cancelled = true;
         };
     }, [auth]);
+    useEffect(() => {
+        const handler = (newUser) => {
+            setUser(newUser);
+        };
+        auth.on('userChanged', handler);
+        return () => {
+            auth.off('userChanged', handler);
+        };
+    }, [auth]);
     if (isLoading) {
         return jsx(Fragment, { children: loadingComponent ?? jsx("div", { children: "Loading..." }) });
     }
@@ -48,6 +57,8 @@ function DotBotsAuthProvider({ auth, children, loadingComponent, errorComponent,
         hasRole: (role) => auth.hasRole(role),
         fetch: (url, options) => auth.fetch(url, options),
         charge: (featureCode, paidBy, quantity) => auth.charge(featureCode, paidBy, quantity),
+        ai: (feature, request) => auth.ai(feature, request),
+        aiStream: (feature, request, onDelta, onDone) => auth.aiStream(feature, request, onDelta, onDone),
         logout: () => auth.logout(),
     };
     return (jsx(DotBotsAuthContext.Provider, { value: value, children: children }));

package/dist/types/types.d.ts

@@ -41,10 +41,51 @@ export interface DotBotsProxyConfig {
 }
 export type ProxyFeature = 'cache' | 'localdb' | 'webhooks' | 'ratelimit';
 export type DotBotsAuthEvent = 'tokenRefreshed' | 'loggedOut' | 'sessionExpired' | 'userLoaded' | 'charged' | 'userChanged';
-export type DotBotsAuthErrorCode = 'IFRAME_TIMEOUT' | 'CODE_EXPIRED' | 'UNAUTHORIZED' | 'REFRESH_FAILED' | 'NETWORK_ERROR' | 'NOT_INITIALIZED' | 'PROXY_UNAVAILABLE' | 'PAYMENT_FAILED';
+export type DotBotsAuthErrorCode = 'IFRAME_TIMEOUT' | 'CODE_EXPIRED' | 'UNAUTHORIZED' | 'REFRESH_FAILED' | 'NETWORK_ERROR' | 'NOT_INITIALIZED' | 'PROXY_UNAVAILABLE' | 'PAYMENT_FAILED' | 'AI_FEATURE_NOT_FOUND' | 'AI_PROVIDER_NOT_CONFIGURED' | 'AI_INSUFFICIENT_BALANCE' | 'AI_CALL_FAILED' | 'AI_STREAM_ERROR';
 export interface TokenPair {
     accessToken: string;
     refreshToken: string;
     expiresIn: number;
 }
 export type DotBotsEnvironment = 'test' | 'prod';
+export interface AiMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string | AiContentBlock[];
+}
+export interface AiContentBlock {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+    };
+}
+export interface AiTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export interface AiRequest {
+    messages: AiMessage[];
+    tools?: AiTool[];
+    maxTokens?: number;
+}
+export interface AiResponse {
+    content: string;
+    model: string;
+    provider: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+    cost: {
+        tokens: number;
+        eur: number;
+    };
+    transactionId: string;
+    toolCalls?: AiToolCall[];
+}
+export interface AiToolCall {
+    name: string;
+    input: Record<string, unknown>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotbots-boutique/auth-sdk",
-  "version": "1.0.15",
+  "version": "1.0.18",
   "description": "Authentication SDK for DotBots marketplace apps",
   "license": "MIT",
   "type": "module",