vocallabsai-sdk 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Subspace
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,328 @@
+# VocalLabs SDK
+
+A lightweight React Native SDK for VocalLabs audio calls with built-in audio streaming. Connect directly to calls using call ID and WebSocket URL - no API polling, no authentication, just simple direct connections.
+
+## Features
+
+- 🎤 **Direct Connection** - Connect directly with call ID and WebSocket URL
+- 🎧 **Audio Streaming** - Real-time audio with WebSocket support
+- 🔇 **Mute Control** - Built-in mute/unmute functionality
+- 📈 **Statistics** - Real-time audio and sending stats
+- 🎯 **Event-Driven** - Comprehensive event system for all actions
+- 📝 **TypeScript** - Full TypeScript support with type definitions
+- ⚡ **Lightweight** - No authentication, no polling, minimal overhead
+
+## Installation
+
+```bash
+npm install vocal-native-sdk
+# or
+yarn add vocal-native-sdk
+```
+
+## Quick Start
+
+```typescript
+import VocalLabsSDK from 'vocal-native-sdk';
+
+// 1. Initialize SDK (optional config)
+const sdk = new VocalLabsSDK({
+  sampleRate: 8000,
+  enableLogs: true,
+});
+
+// 2. Setup event listeners
+sdk.on('onAudioConnected', () => {
+  console.log('Audio connected!');
+});
+
+sdk.on('onUserConnected', (connected) => {
+  console.log('User connected:', connected);
+});
+
+sdk.on('onMuteChanged', (isMuted) => {
+  console.log('Mute status:', isMuted);
+});
+
+// 3. Connect with either callId, websocketUrl, or both
+// If both provided, websocketUrl is used (prioritized)
+
+// Option 1: Just websocket URL (callId extracted from query params)
+await sdk.connect({ websocketUrl: 'wss://rupture2.vocallabs.ai/ws?callId=test-call-123&sampleRate=8000' });
+
+// Option 2: Just call ID
+await sdk.connect({ callId: 'test-call-123' });
+
+// Option 3: Both (websocketUrl takes priority)
+await sdk.connect({ 
+  callId: 'test-call-123', 
+  websocketUrl: 'wss://rupture2.vocallabs.ai/ws?callId=test-call-123&sampleRate=8000' 
+});
+
+// 4. Control the call
+sdk.toggleMute();              // Toggle mute
+sdk.setVolume(0.8);           // Set volume
+const stats = sdk.getStats(); // Get statistics
+
+// 5. Disconnect when done
+sdk.disconnect();
+```
+
+## Configuration
+
+### SDK Configuration Options
+
+```typescript
+interface SDKConfig {
+  sampleRate?: number;       // Optional: Audio sample rate (default: 8000)
+  enableLogs?: boolean;      // Optional: Enable console logs (default: true)
+}
+```
+
+### Example with Custom Configuration
+
+```typescript
+const sdk = new VocalLabsSDK({
+  sampleRate: 16000,
+  enableLogs: false,
+});
+```
+
+## API Reference
+
+### Main Methods
+
+#### `initializeAudioService(audioService)`
+Initialize the SDK with your AudioAPIService instance. **Must be called before connecting audio.**
+
+```typescript
+const audioService = new AudioAPIService();
+sdk.initializeAudioService(audioService);
+```
+
+#### `connect({ callId?, websocketUrl? })`
+Connect directly to a call. Provide either callId, websocketUrl, or both. If both are provided, websocketUrl takes priority.
+
+```typescript
+// With just websocket URL (callId extracted from query params)
+await sdk.connect({ websocketUrl: 'wss://rupture2.vocallabs.ai/ws?callId=test-123&sampleRate=8000' });
+
+// With just call ID
+await sdk.connect({ callId: 'test-123' });
+
+// With both (websocket URL is prioritized)
+await sdk.connect({ 
+  callId: 'test-123', 
+  websocketUrl: 'wss://rupture2.vocallabs.ai/ws?callId=test-123&sampleRate=8000' 
+});
+```
+
+#### `disconnect()`
+Disconnect from the current call and clean up.
+
+```typescript
+sdk.disconnect();
+```
+
+#### `toggleMute()`
+Toggle microphone mute state.
+
+```typescript
+const isMuted = sdk.toggleMute();
+console.log('Muted:', isMuted);
+```
+
+#### `setVolume(volume)`
+Set audio volume (0.0 to 1.0).
+
+```typescript
+sdk.setVolume(0.8);
+```
+
+#### `getState()`
+Get current SDK state.
+
+```typescript
+const state = sdk.getState();
+console.log(state.isConnected, state.isMuted, state.currentCallId);
+```
+
+#### `getStats()`
+Get audio and sending statistics.
+
+```typescript
+const stats = sdk.getStats();
+console.log('Sent chunks:', stats.sending.sentChunks);
+console.log('Received chunks:', stats.audio.receivedChunks);
+```
+
+#### `dispose()`
+Clean up all resources.
+
+```typescript
+await sdk.dispose();
+```
+
+## Events
+
+The SDK provides a comprehensive event system:
+
+### Audio Events
+- `onAudioConnected` - Audio stream connected
+- `onAudioDisconnected` - Audio stream disconnected
+- `onUserConnected` - Other user connected to the call
+- `onUserDisconnected` - Other user disconnected
+- `onMuteChanged` - Mute state changed
+- `onStatsUpdate` - Statistics updated
+
+### General Events
+- `onError` - General error occurred
+- `onLog` - Log message (if logging enabled)
+
+### Event Usage Example
+
+```typescript
+sdk.on('onAudioConnected', () => {
+  console.log('Audio connected successfully');
+});
+
+sdk.on('onUserConnected', (connected) => {
+  if (connected) {
+    console.log('Other user joined the call');
+  }
+});
+});
+
+sdk.on('onStatsUpdate', ({ audio, sending }) => {
+  console.log(`Queue size: ${audio.queueSize}`);
+  console.log(`Sent chunks: ${sending.sentChunks}`);
+});
+```
+
+## Complete Example with React Native Component
+
+```typescript
+import React, { useEffect, useRef, useState } from 'react';
+import { View, Button, Text } from 'react-native';
+import SubspaceCallSDK from 'subspace-call-sdk';
+import AudioAPIService from './services/AudioService';
+
+const CallScreen = ({ userId, friendId }) => {
+  const sdkRef = useRef<VocalLabsSDK | null>(null);
+  const [isConnected, setIsConnected] = useState(false);
+  const [isMuted, setIsMuted] = useState(false);
+
+  useEffect(() => {
+    // Initialize SDK
+    const sdk = new VocalLabsSDK({
+      sampleRate: 8000,
+      enableLogs: true,
+    });
+
+    // Setup listeners
+    sdk.on('onAudioConnected', () => {
+      setIsConnected(true);
+      console.log('Audio connected');
+    });
+
+    sdk.on('onAudioDisconnected', () => {
+      setIsConnected(false);
+    });
+
+    sdk.on('onMuteChanged', (muted) => {
+      setIsMuted(muted);
+    });
+
+    sdkRef.current = sdk;
+
+    return () => {
+      sdk.dispose();
+    };websocketUrl: string) => {
+    if (!sdkRef.current) return;
+    
+    try {
+      // Just provide the websocket URL
+      await sdkRef.current.connect({ websocketUrl }
+    try {
+      // Provide either callId, websocketUrl, or both
+      await sdkRef.current.connect(callId, websocketUrl);
+    } catch (error) {
+      console.error('Failed to connect:', error);
+    }
+  };
+
+  const endCall = () => {
+    sdkRef.current?.disconnect();
+  };
+
+  const toggleMute = () => {
+    sdkRef.current?.toggleMute();
+  };
+
+  return (
+    <View>
+      <Text>Connected: {isConnected ? 'Yes' : 'No'}</Text>
+      <Text>Muted: {isMuted ? 'Yes' : 'No'}</Text>
+      
+      <Button 
+        title="Start Call" 
+        onPress={() => startCall('wss://rupture2.vocallabs.ai/ws?callId=test-123&sampleRate=8000')} 
+      />
+      <Button title="Toggle Mute" onPress={toggleMute} />
+      <Button title="End Call" onPress={endCall} />
+    </View>
+  );
+};
+
+export default CallScreen;
+```
+
+## Error Handling
+
+The SDK provides detailed error information:
+
+```typescript
+import { SDKError, ErrorCode } from 'vocal-native-sdk';
+
+try {
+  await sdk.connect({ websocketUrl: 'wss://rupture2.vocallabs.ai/ws?callId=test-123&sampleRate=8000' });
+} catch (error) {
+  if (error instanceof SDKError) {
+    switch (error.code) {
+      case ErrorCode.INVALID_CONFIG:
+        console.log('Invalid configuration or URL');
+        break;
+      case ErrorCode.AUDIO_CONNECTION_FAILED:
+        console.log('Audio connection failed');
+        break;
+      // ... handle other error codes
+    }
+  }
+}
+```
+
+## TypeScript Support
+
+The SDK is written in TypeScript and provides full type definitions:
+
+```typescript
+import VocalLabsSDK, { 
+  CallData,
+  SDKState,
+  AudioStats,
+  SendingStats 
+} from 'vocal-native-sdk';
+```
+
+## Requirements
+
+- React Native >= 0.60.0
+- React >= 16.8.0
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please open an issue on GitHub.

package/lib/VocalLabsSDK.d.ts

@@ -0,0 +1,33 @@
+import { SDKConfig, SDKState, EventType, EventCallback, CallData, AudioStats, SendingStats } from './types';
+export declare class VocalLabsSDK {
+    private callManager;
+    private audioManager;
+    private logger;
+    private config;
+    private state;
+    private listeners;
+    constructor(config?: SDKConfig);
+    private setupAudioCallbacks;
+    connect(options: {
+        callId?: string;
+        websocketUrl?: string;
+    }): Promise<void>;
+    disconnect(): void;
+    toggleMute(): boolean;
+    setVolume(volume: number): void;
+    clearAudioQueue(): void;
+    getState(): SDKState;
+    getCurrentCall(): CallData | null;
+    getStats(): {
+        audio: AudioStats | null;
+        sending: SendingStats | null;
+    };
+    isMuted(): boolean;
+    isConnected(): boolean;
+    on<T = any>(event: EventType, callback: EventCallback<T>): void;
+    off<T = any>(event: EventType, callback: EventCallback<T>): void;
+    private _emit;
+    dispose(): Promise<void>;
+}
+export default VocalLabsSDK;
+//# sourceMappingURL=VocalLabsSDK.d.ts.map

package/lib/VocalLabsSDK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VocalLabsSDK.d.ts","sourceRoot":"","sources":["../src/VocalLabsSDK.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,SAAS,EACT,QAAQ,EAER,SAAS,EACT,aAAa,EACb,QAAQ,EAGR,UAAU,EACV,YAAY,EACb,MAAM,SAAS,CAAC;AAMjB,qBAAa,YAAY;IAEvB,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,MAAM,CAAS;IAGvB,OAAO,CAAC,MAAM,CAAsB;IAGpC,OAAO,CAAC,KAAK,CAKX;IAGF,OAAO,CAAC,SAAS,CASf;gBAEU,MAAM,CAAC,EAAE,SAAS;IA8B9B,OAAO,CAAC,mBAAmB;IAqCrB,OAAO,CAAC,OAAO,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAyDjF,UAAU,IAAI,IAAI;IAoBlB,UAAU,IAAI,OAAO;IAcrB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO/B,eAAe,IAAI,IAAI;IAOvB,QAAQ,IAAI,QAAQ;IAOpB,cAAc,IAAI,QAAQ,GAAG,IAAI;IAOjC,QAAQ,IAAI;QAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;QAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAA;KAAE;IAOtE,OAAO,IAAI,OAAO;IAOlB,WAAW,IAAI,OAAO;IAOtB,EAAE,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAW/D,GAAG,CAAC,CAAC,GAAG,GAAG,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI;IAWhE,OAAO,CAAC,KAAK;IAeP,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CA2B/B;AAED,eAAe,YAAY,CAAC"}

package/lib/VocalLabsSDK.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VocalLabsSDK = void 0;
+const types_1 = require("./types");
+const constants_1 = require("./config/constants");
+const logger_1 = require("./utils/logger");
+const CallManager_1 = require("./call/CallManager");
+const AudioManager_1 = require("./audio/AudioManager");
+class VocalLabsSDK {
+    constructor(config) {
+        this.state = {
+            isInitialized: false,
+            isConnected: false,
+            currentCallId: null,
+            isMuted: false,
+        };
+        this.listeners = {
+            onAudioConnected: [],
+            onAudioDisconnected: [],
+            onUserConnected: [],
+            onUserDisconnected: [],
+            onMuteChanged: [],
+            onStatsUpdate: [],
+            onError: [],
+            onLog: [],
+        };
+        this.config = {
+            sampleRate: config?.sampleRate || constants_1.DEFAULT_CONFIG.SAMPLE_RATE,
+            enableLogs: config?.enableLogs !== false,
+        };
+        this.logger = new logger_1.Logger(this.config.enableLogs);
+        this.logger.setLogCallback((message, type) => {
+            this._emit('onLog', { message, type });
+        });
+        this.callManager = new CallManager_1.CallManager(this.logger);
+        this.audioManager = new AudioManager_1.AudioManager(this.logger, this.config.sampleRate);
+        this.setupAudioCallbacks();
+        this.logger.info('🚀 VocalLabs SDK initialized with built-in audio support');
+        this.state.isInitialized = true;
+    }
+    setupAudioCallbacks() {
+        this.audioManager.onConnected(() => {
+            this.state.isConnected = true;
+            this._emit('onAudioConnected');
+        });
+        this.audioManager.onDisconnected(() => {
+            this.state.isConnected = false;
+            this._emit('onAudioDisconnected');
+        });
+        this.audioManager.onMuteChanged((isMuted) => {
+            this.state.isMuted = isMuted;
+            this._emit('onMuteChanged', isMuted);
+        });
+        this.audioManager.onUserConnected((connected) => {
+            if (connected) {
+                this._emit('onUserConnected', true);
+            }
+            else {
+                this._emit('onUserDisconnected', false);
+            }
+        });
+        this.audioManager.onStatsUpdate((stats) => {
+            this._emit('onStatsUpdate', stats);
+        });
+    }
+    async connect(options) {
+        try {
+            if (!this.state.isInitialized) {
+                throw new types_1.SDKError('SDK not initialized', types_1.ErrorCode.NOT_INITIALIZED);
+            }
+            let { callId, websocketUrl } = options;
+            if (!callId && !websocketUrl) {
+                throw new types_1.SDKError('Either callId or websocketUrl must be provided', types_1.ErrorCode.INVALID_CONFIG);
+            }
+            if (!callId && websocketUrl) {
+                try {
+                    const url = new URL(websocketUrl);
+                    const callIdParam = url.searchParams.get('callId');
+                    callId = callIdParam || `call-${Date.now()}`;
+                    this.logger.info(`Extracted callId from URL: ${callId}`);
+                }
+                catch (e) {
+                    callId = `call-${Date.now()}`;
+                    this.logger.warning('Could not parse URL, using generated callId');
+                }
+            }
+            this.logger.info(`Connecting to call: ${callId}`);
+            const callData = {
+                call_id: callId,
+                websocket: websocketUrl || '',
+            };
+            this.callManager.setCurrentCall(callData);
+            this.state.currentCallId = callId;
+            await this.audioManager.connect({
+                callId: callId,
+                sampleRate: this.config.sampleRate,
+                wsUrl: websocketUrl,
+            });
+            this.logger.info('✅ Connected successfully');
+        }
+        catch (error) {
+            this._emit('onError', error);
+            throw error;
+        }
+    }
+    disconnect() {
+        this.logger.info('Disconnecting...');
+        this.audioManager.disconnect();
+        this.callManager.clearCurrentCall();
+        this.state.isConnected = false;
+        this.state.currentCallId = null;
+        this.state.isMuted = false;
+        this.logger.info('✅ Disconnected');
+    }
+    toggleMute() {
+        try {
+            const isMuted = this.audioManager.toggleMute();
+            this.state.isMuted = isMuted;
+            return isMuted;
+        }
+        catch (error) {
+            this._emit('onError', error);
+            throw error;
+        }
+    }
+    setVolume(volume) {
+        this.audioManager.setVolume(volume);
+    }
+    clearAudioQueue() {
+        this.audioManager.clearQueue();
+    }
+    getState() {
+        return { ...this.state };
+    }
+    getCurrentCall() {
+        return this.callManager.getCurrentCall();
+    }
+    getStats() {
+        return this.audioManager.getStats();
+    }
+    isMuted() {
+        return this.state.isMuted;
+    }
+    isConnected() {
+        return this.state.isConnected;
+    }
+    on(event, callback) {
+        if (this.listeners[event]) {
+            this.listeners[event].push(callback);
+        }
+        else {
+            this.logger.warning(`Unknown event: ${event}`);
+        }
+    }
+    off(event, callback) {
+        if (this.listeners[event]) {
+            this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+        }
+    }
+    _emit(event, data) {
+        if (this.listeners[event]) {
+            this.listeners[event].forEach((callback) => {
+                try {
+                    callback(data);
+                }
+                catch (error) {
+                    this.logger.error(`Error in ${event} listener:`, error);
+                }
+            });
+        }
+    }
+    async dispose() {
+        this.logger.info('Disposing SDK...');
+        if (this.state.isConnected) {
+            this.disconnect();
+        }
+        this.callManager.dispose();
+        await this.audioManager.dispose();
+        Object.keys(this.listeners).forEach((key) => {
+            this.listeners[key] = [];
+        });
+        this.state = {
+            isInitialized: false,
+            isConnected: false,
+            currentCallId: null,
+            isMuted: false,
+        };
+        this.logger.info('✅ SDK disposed');
+    }
+}
+exports.VocalLabsSDK = VocalLabsSDK;
+exports.default = VocalLabsSDK;

package/lib/audio/AudioManager.d.ts

@@ -0,0 +1,37 @@
+import { AudioStats, SendingStats, AudioConnectionOptions } from '../types';
+import { Logger } from '../utils/logger';
+export declare class AudioManager {
+    private audioService;
+    private logger;
+    private sampleRate;
+    private isInitialized;
+    private onConnectedCallback?;
+    private onDisconnectedCallback?;
+    private onMuteChangedCallback?;
+    private onUserConnectedCallback?;
+    private onStatsUpdateCallback?;
+    constructor(logger: Logger, sampleRate?: number);
+    isServiceInitialized(): boolean;
+    private setupCallbacks;
+    connect(options: AudioConnectionOptions): Promise<void>;
+    disconnect(): void;
+    toggleMute(): boolean;
+    isMuted(): boolean;
+    isConnected(): boolean;
+    setVolume(volume: number): void;
+    clearQueue(): void;
+    getStats(): {
+        audio: AudioStats;
+        sending: SendingStats;
+    };
+    onConnected(callback: () => void): void;
+    onDisconnected(callback: () => void): void;
+    onMuteChanged(callback: (isMuted: boolean) => void): void;
+    onUserConnected(callback: (connected: boolean) => void): void;
+    onStatsUpdate(callback: (stats: {
+        audio: AudioStats;
+        sending: SendingStats;
+    }) => void): void;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=AudioManager.d.ts.map

package/lib/audio/AudioManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioManager.d.ts","sourceRoot":"","sources":["../../src/audio/AudioManager.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,sBAAsB,EAAuB,MAAM,UAAU,CAAC;AACjG,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAIzC,qBAAa,YAAY;IACvB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,aAAa,CAAkB;IAGvC,OAAO,CAAC,mBAAmB,CAAC,CAAa;IACzC,OAAO,CAAC,sBAAsB,CAAC,CAAa;IAC5C,OAAO,CAAC,qBAAqB,CAAC,CAA6B;IAC3D,OAAO,CAAC,uBAAuB,CAAC,CAA+B;IAC/D,OAAO,CAAC,qBAAqB,CAAC,CAAgE;gBAElF,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAmC;IAc3E,oBAAoB,IAAI,OAAO;IAO/B,OAAO,CAAC,cAAc;IA+ChB,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC7D,UAAU,IAAI,IAAI;IAQlB,UAAU,IAAI,OAAO;IAQrB,OAAO,IAAI,OAAO;IAOlB,WAAW,IAAI,OAAO;IAOtB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO/B,UAAU,IAAI,IAAI;IAOlB,QAAQ,IAAI;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,YAAY,CAAA;KAAE;IAUxD,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI;IAIhC,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI;IAInC,aAAa,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI;IAIlD,eAAe,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI;IAItD,aAAa,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,KAAK,EAAE,UAAU,CAAC;QAAC,OAAO,EAAE,YAAY,CAAA;KAAE,KAAK,IAAI;IAO/E,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAK/B"}