diff --git a/demo/app.css b/demo/app.css
index aa00deb6..e499c955 100644
--- a/demo/app.css
+++ b/demo/app.css
@@ -165,6 +165,16 @@ input[type='text'][placeholder='Chat Mode (Functional | Conversational)']:focus
     background-color: black;
 }
 
+.camera-preview {
+    width: 100%;
+    aspect-ratio: 4 / 3;
+    border-radius: 8px;
+    background-color: #000;
+    border: 1px solid #444;
+    object-fit: cover;
+    transform: scaleX(-1);
+}
+
 .animated {
     border: 2px solid #ffcc00;
 }
diff --git a/demo/app.tsx b/demo/app.tsx
index 4d10b3ac..b99035c6 100644
--- a/demo/app.tsx
+++ b/demo/app.tsx
@@ -20,7 +20,15 @@ export function App() {
     const [audioInputDevices, setAudioInputDevices] = useState<MediaDeviceInfo[]>([]);
     const [selectedAudioDeviceId, setSelectedAudioDeviceId] = useState<string>('');
 
+    const [isCameraOn, setIsCameraOn] = useState(false);
+    const [cameraStream, setCameraStream] = useState<MediaStream | undefined>(undefined);
+    const [videoInputDevices, setVideoInputDevices] = useState<MediaDeviceInfo[]>([]);
+    const [selectedVideoDeviceId, setSelectedVideoDeviceId] = useState<string>('');
+    const cameraStreamRef = useRef<MediaStream | undefined>(undefined);
+    const hasSetDefaultVideoDevice = useRef(false);
+
     const videoRef = useRef<HTMLVideoElement>(null);
+    const cameraPreviewRef = useRef<HTMLVideoElement>(null);
 
     const {
         srcObject,
@@ -36,6 +44,10 @@ export function App() {
         unpublishMicrophoneStream,
         microphoneEnabled,
         isMicrophonePublished,
+        publishCameraStream,
+        unpublishCameraStream,
+        isCameraPublished,
+        cameraEnabled,
     } = useAgentManager({
         debug,
         agentId,
@@ -55,6 +67,68 @@ export function App() {
         }
     }, []);
 
+    const cleanupCameraStream = useCallback(() => {
+        if (cameraStreamRef.current) {
+            cameraStreamRef.current.getTracks().forEach(track => track.stop());
+            cameraStreamRef.current = undefined;
+            setCameraStream(undefined);
+            hasSetDefaultVideoDevice.current = false;
+        }
+    }, []);
+
+    const handleDisconnect = useCallback(async () => {
+        try {
+            await disconnect();
+        } finally {
+            cleanupCameraStream();
+            setIsCameraOn(false);
+        }
+    }, [disconnect, cleanupCameraStream]);
+
+    const updateVideoDevices = useCallback(async () => {
+        try {
+            const tempStream = await navigator.mediaDevices.getUserMedia({ video: true });
+            tempStream.getTracks().forEach(track => track.stop());
+            const devices = await navigator.mediaDevices.enumerateDevices();
+            const videoInputs = devices.filter(device => device.kind === 'videoinput');
+            setVideoInputDevices(videoInputs);
+            if (videoInputs.length > 0 && !hasSetDefaultVideoDevice.current) {
+                hasSetDefaultVideoDevice.current = true;
+                setSelectedVideoDeviceId(videoInputs[0].deviceId);
+            }
+        } catch (error) {
+            console.error('Failed to enumerate video devices:', error);
+        }
+    }, []);
+
+    const handleCameraToggle = useCallback(
+        async (enabled: boolean) => {
+            if (enabled) {
+                try {
+                    const videoConstraints: MediaStreamConstraints['video'] = selectedVideoDeviceId
+                        ? { deviceId: { exact: selectedVideoDeviceId } }
+                        : true;
+                    const stream = await navigator.mediaDevices.getUserMedia({ video: videoConstraints });
+                    cameraStreamRef.current = stream;
+                    setCameraStream(stream);
+                } catch (error) {
+                    console.error('Failed to get camera access:', error);
+                    alert('Failed to access camera. Please check permissions.');
+                    return;
+                }
+            } else {
+                try {
+                    await unpublishCameraStream();
+                } catch (error) {
+                    console.error('Failed to unpublish camera stream:', error);
+                }
+                cleanupCameraStream();
+            }
+            setIsCameraOn(enabled);
+        },
+        [selectedVideoDeviceId, unpublishCameraStream, cleanupCameraStream]
+    );
+
     const updateAudioDevices = useCallback(async () => {
         try {
             await navigator.mediaDevices.getUserMedia({ audio: true });
@@ -163,6 +237,36 @@ export function App() {
         }
     }, [enableMicrophone, updateAudioDevices]);
 
+    useEffect(() => {
+        return cleanupCameraStream;
+    }, [cleanupCameraStream]);
+
+    useEffect(() => {
+        if (cameraPreviewRef.current) {
+            cameraPreviewRef.current.srcObject = cameraStream ?? null;
+        }
+    }, [cameraStream]);
+
+    useEffect(() => {
+        if (isCameraOn) {
+            updateVideoDevices();
+        }
+    }, [isCameraOn, updateVideoDevices]);
+
+    useEffect(() => {
+        if (
+            connectionState === ConnectionState.Connected &&
+            isCameraOn &&
+            publishCameraStream &&
+            cameraStreamRef.current &&
+            !isCameraPublished
+        ) {
+            publishCameraStream(cameraStreamRef.current).catch(error => {
+                console.error('Failed to publish camera stream:', error);
+            });
+        }
+    }, [connectionState, isCameraOn, publishCameraStream, isCameraPublished]);
+
     useEffect(() => {
         if (srcObject && videoRef.current) {
             videoRef.current.srcObject = srcObject;
@@ -225,7 +329,7 @@ export function App() {
                             Interrupt
                         </button>
 
-                        <button onClick={disconnect} disabled={connectionState !== ConnectionState.Connected}>
+                        <button onClick={handleDisconnect} disabled={connectionState !== ConnectionState.Connected}>
                             Close Connection
                         </button>
 
@@ -261,6 +365,18 @@ export function App() {
                                     Microphone
                                 </label>
                             )}
+
+                            {cameraEnabled && (
+                                <label>
+                                    <input
+                                        type="checkbox"
+                                        name="camera"
+                                        checked={isCameraOn}
+                                        onChange={e => handleCameraToggle(e.currentTarget.checked)}
+                                    />
+                                    Camera
+                                </label>
+                            )}
                         </div>
                         {microphoneEnabled && enableMicrophone && audioInputDevices.length > 0 && (
                             <div className="input-options" style={{ marginTop: '10px' }}>
@@ -280,6 +396,33 @@ export function App() {
                                 </label>
                             </div>
                         )}
+                        {isCameraOn && videoInputDevices.length > 0 && (
+                            <div className="input-options" style={{ marginTop: '10px' }}>
+                                <label>
+                                    Camera Device:
+                                    <select
+                                        value={selectedVideoDeviceId}
+                                        onChange={e => setSelectedVideoDeviceId(e.currentTarget.value)}
+                                        disabled={connectionState === ConnectionState.Connected}
+                                        style={{ marginLeft: '10px', minWidth: '200px' }}>
+                                        {videoInputDevices.map(device => (
+                                            <option key={device.deviceId} value={device.deviceId}>
+                                                {device.label || `Camera ${device.deviceId.substring(0, 8)}`}
+                                            </option>
+                                        ))}
+                                    </select>
+                                </label>
+                            </div>
+                        )}
+                        {isCameraOn && (
+                            <video
+                                ref={cameraPreviewRef}
+                                className="camera-preview"
+                                autoPlay
+                                playsInline
+                                muted
+                            />
+                        )}
                     </fieldset>
                 </div>
             </section>
diff --git a/demo/hooks/useAgentManager.ts b/demo/hooks/useAgentManager.ts
index d3011e0d..9d8aa0ec 100644
--- a/demo/hooks/useAgentManager.ts
+++ b/demo/hooks/useAgentManager.ts
@@ -53,6 +53,7 @@ export function useAgentManager(props: UseAgentManagerOptions) {
     const [agentManager, setAgentManager] = useState<AgentManager | null>(null);
     const [connectionState, setConnectionState] = useState<ConnectionState>(ConnectionState.New);
     const [isMicrophonePublished, setIsMicrophonePublished] = useState(false);
+    const [isCameraPublished, setIsCameraPublished] = useState(false);
     const streamType = agentManager?.getStreamType();
 
     useEffect(() => {
@@ -80,6 +81,8 @@ export function useAgentManager(props: UseAgentManagerOptions) {
 
                         if (state !== ConnectionState.Connected) {
                             setAgentManager(null);
+                            setIsMicrophonePublished(false);
+                            setIsCameraPublished(false);
                         }
                     },
                     onVideoStateChange(state) {
@@ -131,6 +134,8 @@ export function useAgentManager(props: UseAgentManagerOptions) {
             setSrcObject(null);
             setConnectionState(ConnectionState.New);
             setMessages([]);
+            setIsMicrophonePublished(false);
+            setIsCameraPublished(false);
         }
     }, [agentManager]);
 
@@ -211,6 +216,33 @@ export function useAgentManager(props: UseAgentManagerOptions) {
         setIsMicrophonePublished(false);
     }, [agentManager]);
 
+    const publishCameraStream = useCallback(
+        async (stream: MediaStream) => {
+            if (!agentManager) {
+                console.warn('Agent manager is not initialized yet. Will retry when ready.');
+                return;
+            }
+            if (!agentManager.publishCameraStream) {
+                throw new Error('publishCameraStream is not available for this streaming manager');
+            }
+            await agentManager.publishCameraStream(stream);
+            setIsCameraPublished(true);
+        },
+        [agentManager]
+    );
+
+    const unpublishCameraStream = useCallback(async () => {
+        if (!agentManager) {
+            console.warn('Agent manager is not initialized yet.');
+            return;
+        }
+        if (!agentManager.unpublishCameraStream) {
+            throw new Error('unpublishCameraStream is not available for this streaming manager');
+        }
+        await agentManager.unpublishCameraStream();
+        setIsCameraPublished(false);
+    }, [agentManager]);
+
     const microphoneEnabled = useMemo(() => {
         return (
             agentManager?.agent?.presenter?.type === 'expressive' &&
@@ -218,6 +250,10 @@ export function useAgentManager(props: UseAgentManagerOptions) {
         );
     }, [agentManager]);
 
+    const cameraEnabled = useMemo(() => {
+        return !!agentManager?.agent?.vision?.enabled && typeof agentManager?.publishCameraStream === 'function';
+    }, [agentManager]);
+
     return {
         connectionState,
         messages,
@@ -232,5 +268,9 @@ export function useAgentManager(props: UseAgentManagerOptions) {
         unpublishMicrophoneStream,
         microphoneEnabled,
         isMicrophonePublished,
+        publishCameraStream,
+        unpublishCameraStream,
+        isCameraPublished,
+        cameraEnabled,
     };
 }
diff --git a/src/services/agent-manager/index.test.ts b/src/services/agent-manager/index.test.ts
index 3a4ab324..f6a7e584 100644
--- a/src/services/agent-manager/index.test.ts
+++ b/src/services/agent-manager/index.test.ts
@@ -751,6 +751,59 @@ describe('createAgentManager', () => {
         });
     });
 
+    describe('publishCameraStream', () => {
+        let manager: AgentManager;
+
+        beforeEach(async () => {
+            manager = await createAgentManager('agent-123', mockOptions);
+            await manager.connect();
+        });
+
+        it('should publish camera stream when available', async () => {
+            const mockStream = new MediaStream();
+            const mockPublish = jest.fn().mockResolvedValue(undefined);
+            mockStreamingManager.publishCameraStream = mockPublish;
+
+            await manager.publishCameraStream?.(mockStream);
+
+            expect(mockPublish).toHaveBeenCalledWith(mockStream);
+        });
+
+        it('should throw error when publishCameraStream is not available', async () => {
+            mockStreamingManager.publishCameraStream = undefined;
+
+            await expect(manager.publishCameraStream?.(new MediaStream())).rejects.toThrow(
+                'publishCameraStream is not available for this streaming manager'
+            );
+        });
+    });
+
+    describe('unpublishCameraStream', () => {
+        let manager: AgentManager;
+
+        beforeEach(async () => {
+            manager = await createAgentManager('agent-123', mockOptions);
+            await manager.connect();
+        });
+
+        it('should unpublish camera stream when available', async () => {
+            const mockUnpublish = jest.fn().mockResolvedValue(undefined);
+            mockStreamingManager.unpublishCameraStream = mockUnpublish;
+
+            await manager.unpublishCameraStream?.();
+
+            expect(mockUnpublish).toHaveBeenCalled();
+        });
+
+        it('should throw error when unpublishCameraStream is not available', async () => {
+            mockStreamingManager.unpublishCameraStream = undefined;
+
+            await expect(manager.unpublishCameraStream?.()).rejects.toThrow(
+                'unpublishCameraStream is not available for this streaming manager'
+            );
+        });
+    });
+
     describe('DirectPlayback mode', () => {
         it('should not create socket manager in DirectPlayback mode', async () => {
             const directPlaybackOptions = { ...mockOptions, mode: ChatMode.DirectPlayback };
diff --git a/src/services/agent-manager/index.ts b/src/services/agent-manager/index.ts
index 49dd38cb..33dd565e 100644
--- a/src/services/agent-manager/index.ts
+++ b/src/services/agent-manager/index.ts
@@ -287,6 +287,18 @@ export async function createAgentManager(agent: string, options: AgentManagerOpt
             }
             return items.streamingManager.unpublishMicrophoneStream();
         },
+        async publishCameraStream(stream: MediaStream) {
+            if (!items.streamingManager?.publishCameraStream) {
+                throw new Error('publishCameraStream is not available for this streaming manager');
+            }
+            return items.streamingManager.publishCameraStream(stream);
+        },
+        async unpublishCameraStream() {
+            if (!items.streamingManager?.unpublishCameraStream) {
+                throw new Error('unpublishCameraStream is not available for this streaming manager');
+            }
+            return items.streamingManager.unpublishCameraStream();
+        },
         async chat(userMessage: string) {
             const validateChatRequest = () => {
                 if (isChatModeWithoutChat(mode)) {
diff --git a/src/services/streaming-manager/common.ts b/src/services/streaming-manager/common.ts
index d0ceb9cd..ce6d7401 100644
--- a/src/services/streaming-manager/common.ts
+++ b/src/services/streaming-manager/common.ts
@@ -47,6 +47,20 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      */
     unpublishMicrophoneStream?(): Promise<void>;
 
+    /**
+     * Publish a camera video stream to the LiveKit room.
+     * Can be called after connection to enable vision.
+     * supported only for livekit manager
+     */
+    publishCameraStream?(stream: MediaStream): Promise<void>;
+
+    /**
+     * Unpublish the currently published camera stream.
+     * Can be called after connection to disable vision.
+     * supported only for livekit manager
+     */
+    unpublishCameraStream?(): Promise<void>;
+
     /**
      * Session identifier information, should be returned in the body of all streaming requests
      */
diff --git a/src/services/streaming-manager/livekit-manager.test.ts b/src/services/streaming-manager/livekit-manager.test.ts
index dfe3ce81..96c9a69c 100644
--- a/src/services/streaming-manager/livekit-manager.test.ts
+++ b/src/services/streaming-manager/livekit-manager.test.ts
@@ -16,6 +16,7 @@ const mockLocalParticipant = {
     unpublishTrack: mockUnpublishTrack,
     sendText: jest.fn(),
     audioTrackPublications: new Map(),
+    videoTrackPublications: new Map(),
 };
 
 const mockRoom = {
@@ -31,6 +32,7 @@ const mockRoomConstructor = jest.fn().mockImplementation(() => mockRoom);
 const mockTrack = {
     Source: {
         Microphone: 'microphone',
+        Camera: 'camera',
     },
 };
 
@@ -113,6 +115,9 @@ const TEST_AGENT_ID = 'agent123';
 const TEST_TRACK_SID = 'track-sid-123';
 const TEST_AUDIO_TRACK_ID = 'audio-track-1';
 const TEST_AUDIO_TRACK_ID_2 = 'audio-track-2';
+const TEST_VIDEO_TRACK_ID = 'video-track-1';
+const TEST_VIDEO_TRACK_ID_2 = 'video-track-2';
+const TEST_CAMERA_TRACK_SID = 'camera-track-sid-123';
 const ASYNC_WAIT_TIME = 10;
 
 // Helper functions to create mock objects
@@ -151,6 +156,36 @@ function createMockStream(audioTracks: any[] = [createMockAudioTrack()]) {
     return stream;
 }
 
+function createMockCameraTrack(id: string = TEST_VIDEO_TRACK_ID, additionalProps: any = {}) {
+    return {
+        kind: 'video',
+        id,
+        enabled: true,
+        stop: jest.fn(),
+        ...additionalProps,
+    } as any;
+}
+
+function createMockCameraPublication(trackId: string = TEST_VIDEO_TRACK_ID, trackSid: string = TEST_CAMERA_TRACK_SID) {
+    const track = {
+        kind: 'video',
+        id: trackId,
+        mediaStreamTrack: createMockCameraTrack(trackId),
+    } as any;
+    return {
+        trackSid,
+        track,
+        source: 'camera',
+    } as any;
+}
+
+function createMockCameraStream(videoTracks: any[] = [createMockCameraTrack()]) {
+    const stream = new MediaStream(videoTracks);
+    (stream as any).getVideoTracks = jest.fn(() => videoTracks);
+    (stream as any).getTracks = jest.fn(() => videoTracks);
+    return stream;
+}
+
 function getConnectionStateHandler(index?: number) {
     const calls = mockRoom.on.mock.calls.filter((call: any[]) => call[0] === 'ConnectionStateChanged');
     if (index !== undefined && calls[index]) {
@@ -221,6 +256,8 @@ describe('LiveKit Streaming Manager - Microphone Stream', () => {
         mockVideoStatsMonitor.start.mockClear();
         mockVideoStatsMonitor.stop.mockClear();
         mockVideoStatsMonitor.getReport.mockClear();
+        mockLocalParticipant.audioTrackPublications = new Map();
+        mockLocalParticipant.videoTrackPublications = new Map();
         agentId = TEST_AGENT_ID;
         sessionOptions = {
             chat_persist: true,
@@ -312,7 +349,7 @@ describe('LiveKit Streaming Manager - Microphone Stream', () => {
             await manager.publishMicrophoneStream?.(mockStream);
             await manager.disconnect();
 
-            expect(mockUnpublishTrack).toHaveBeenCalledWith(mockPublication.track);
+            expect(mockUnpublishTrack).toHaveBeenCalledWith(mockPublication.track, false);
         });
 
         it('should handle track publication lifecycle correctly', async () => {
@@ -748,3 +785,320 @@ describe('LiveKit Streaming Manager - Microphone Stream', () => {
         });
     });
 });
+
+describe('LiveKit Streaming Manager - Camera Stream', () => {
+    let agentId: string;
+    let sessionOptions: CreateSessionV2Options;
+    let options: StreamingManagerOptions;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockRoom.connect.mockResolvedValue(undefined);
+        mockRoom.prepareConnection.mockResolvedValue(undefined);
+        mockRoom.disconnect.mockResolvedValue(undefined);
+        mockRoom.on.mockReturnThis();
+        mockLocalParticipant.audioTrackPublications = new Map();
+        mockLocalParticipant.videoTrackPublications = new Map();
+        agentId = TEST_AGENT_ID;
+        sessionOptions = {
+            chat_persist: true,
+            transport_provider: 'livekit' as any,
+        };
+        options = StreamingManagerOptionsFactory.build();
+    });
+
+    describe('Camera Stream Publishing', () => {
+        it('should publish camera track using publishCameraStream', async () => {
+            // ARRANGE:
+            const mockVideoTrack = createMockCameraTrack();
+            const mockStream = createMockCameraStream([mockVideoTrack]);
+            const mockPublication = createMockCameraPublication();
+            mockPublishTrack.mockResolvedValue(mockPublication);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT:
+            await manager.publishCameraStream?.(mockStream);
+
+            // ASSERT:
+            expect(mockPublishTrack).toHaveBeenCalledWith(mockVideoTrack, {
+                source: 'camera',
+            });
+        });
+
+        it('should throw error when no video track in stream', async () => {
+            // ARRANGE:
+            const emptyStream = createMockCameraStream([]);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT + ASSERT:
+            await expect(manager.publishCameraStream?.(emptyStream)).rejects.toThrow(
+                'No camera track found in the provided MediaStream'
+            );
+        });
+
+        it('should throw error when publishing camera before connection', async () => {
+            // ARRANGE:
+            const mockStream = createMockCameraStream();
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+
+            // ACT + ASSERT:
+            await expect(manager.publishCameraStream?.(mockStream)).rejects.toThrow('Room is not connected');
+        });
+
+        it('should throw error on camera publish failure', async () => {
+            // ARRANGE:
+            const mockStream = createMockCameraStream();
+            mockPublishTrack.mockRejectedValue(new Error('Failed to publish camera'));
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT + ASSERT:
+            await expect(manager.publishCameraStream?.(mockStream)).rejects.toThrow('Failed to publish camera');
+        });
+
+        it('should skip when same camera track is already published', async () => {
+            // ARRANGE:
+            const mockVideoTrack = createMockCameraTrack();
+            const mockStream = createMockCameraStream([mockVideoTrack]);
+            const mockPublication = createMockCameraPublication();
+            mockPublishTrack.mockResolvedValue(mockPublication);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            mockLocalParticipant.videoTrackPublications.set('pub-1', {
+                source: 'camera',
+                track: { mediaStreamTrack: mockVideoTrack },
+            });
+
+            // ACT:
+            await manager.publishCameraStream?.(mockStream);
+
+            // ASSERT:
+            expect(mockPublishTrack).not.toHaveBeenCalled();
+        });
+
+        it('should unpublish existing camera track before publishing a different one', async () => {
+            // ARRANGE:
+            const firstTrack = createMockCameraTrack(TEST_VIDEO_TRACK_ID);
+            const firstStream = createMockCameraStream([firstTrack]);
+            const firstPublication = createMockCameraPublication(TEST_VIDEO_TRACK_ID);
+            mockPublishTrack.mockResolvedValue(firstPublication);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+            await manager.publishCameraStream?.(firstStream);
+
+            const secondTrack = createMockCameraTrack(TEST_VIDEO_TRACK_ID_2);
+            const secondStream = createMockCameraStream([secondTrack]);
+            const secondPublication = createMockCameraPublication(TEST_VIDEO_TRACK_ID_2);
+            mockPublishTrack.mockResolvedValue(secondPublication);
+
+            // ACT:
+            await manager.publishCameraStream?.(secondStream);
+
+            // ASSERT:
+            expect(mockUnpublishTrack).toHaveBeenCalledWith(firstPublication.track, false);
+            expect(mockPublishTrack).toHaveBeenCalledTimes(2);
+            expect(mockPublishTrack).toHaveBeenLastCalledWith(secondTrack, { source: 'camera' });
+        });
+    });
+
+    describe('Camera Unpublish', () => {
+        it('should unpublish camera track on disconnect', async () => {
+            // ARRANGE:
+            const mockStream = createMockCameraStream();
+            const mockPublication = createMockCameraPublication();
+            mockPublishTrack.mockResolvedValue(mockPublication);
+            mockUnpublishTrack.mockResolvedValue(undefined);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+            await manager.publishCameraStream?.(mockStream);
+
+            // ACT:
+            await manager.disconnect();
+
+            // ASSERT:
+            expect(mockUnpublishTrack).toHaveBeenCalledWith(mockPublication.track, false);
+        });
+
+        it('should not fail when unpublishing camera without prior publish', async () => {
+            // ARRANGE:
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT:
+            await manager.unpublishCameraStream?.();
+
+            // ASSERT:
+            expect(mockUnpublishTrack).not.toHaveBeenCalled();
+        });
+
+        it('should handle explicit unpublish via unpublishCameraStream', async () => {
+            // ARRANGE:
+            const mockStream = createMockCameraStream();
+            const mockPublication = createMockCameraPublication();
+            mockPublishTrack.mockResolvedValue(mockPublication);
+            mockUnpublishTrack.mockResolvedValue(undefined);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+            await manager.publishCameraStream?.(mockStream);
+
+            // ACT:
+            await manager.unpublishCameraStream?.();
+
+            // ASSERT:
+            expect(mockUnpublishTrack).toHaveBeenCalledWith(mockPublication.track, false);
+        });
+    });
+
+    describe('Concurrent Publish Guard', () => {
+        it('should skip camera publish when already in progress', async () => {
+            // ARRANGE:
+            const mockStream = createMockCameraStream();
+            let resolvePublish: (value: any) => void;
+            const slowPublish = new Promise(resolve => {
+                resolvePublish = resolve;
+            });
+            mockPublishTrack.mockReturnValue(slowPublish);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT:
+            const firstPublish = manager.publishCameraStream?.(mockStream);
+            const secondPublish = manager.publishCameraStream?.(mockStream);
+
+            resolvePublish!(createMockCameraPublication());
+            await firstPublish;
+            await secondPublish;
+
+            // ASSERT:
+            expect(mockPublishTrack).toHaveBeenCalledTimes(1);
+        });
+
+        it('should skip microphone publish when already in progress', async () => {
+            // ARRANGE:
+            const mockStream = createMockStream();
+            let resolvePublish: (value: any) => void;
+            const slowPublish = new Promise(resolve => {
+                resolvePublish = resolve;
+            });
+            mockPublishTrack.mockReturnValue(slowPublish);
+
+            const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+            await simulateConnection();
+
+            // ACT:
+            const firstPublish = manager.publishMicrophoneStream?.(mockStream);
+            const secondPublish = manager.publishMicrophoneStream?.(mockStream);
+
+            resolvePublish!(createMockPublication());
+            await firstPublish;
+            await secondPublish;
+
+            // ASSERT:
+            expect(mockPublishTrack).toHaveBeenCalledTimes(1);
+        });
+    });
+});
+
+describe('LiveKit Streaming Manager - Disconnect Behavior', () => {
+    let agentId: string;
+    let sessionOptions: CreateSessionV2Options;
+    let options: StreamingManagerOptions;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockRoom.connect.mockResolvedValue(undefined);
+        mockRoom.prepareConnection.mockResolvedValue(undefined);
+        mockRoom.disconnect.mockResolvedValue(undefined);
+        mockRoom.on.mockReturnThis();
+        mockLocalParticipant.audioTrackPublications = new Map();
+        mockLocalParticipant.videoTrackPublications = new Map();
+        agentId = TEST_AGENT_ID;
+        sessionOptions = {
+            chat_persist: true,
+            transport_provider: 'livekit' as any,
+        };
+        options = StreamingManagerOptionsFactory.build();
+    });
+
+    it('should unpublish both mic and camera on disconnect', async () => {
+        // ARRANGE:
+        const micStream = createMockStream();
+        const micPub = createMockPublication();
+        const camStream = createMockCameraStream();
+        const camPub = createMockCameraPublication();
+        mockPublishTrack.mockResolvedValueOnce(micPub).mockResolvedValueOnce(camPub);
+        mockUnpublishTrack.mockResolvedValue(undefined);
+
+        const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+        await simulateConnection();
+        await manager.publishMicrophoneStream?.(micStream);
+        await manager.publishCameraStream?.(camStream);
+
+        // ACT:
+        await manager.disconnect();
+
+        // ASSERT:
+        expect(mockUnpublishTrack).toHaveBeenCalledWith(micPub.track, false);
+        expect(mockUnpublishTrack).toHaveBeenCalledWith(camPub.track, false);
+    });
+
+    it('should allow re-publishing camera after disconnect and reconnect', async () => {
+        // ARRANGE:
+        const camStream = createMockCameraStream();
+        const camPub = createMockCameraPublication();
+        mockPublishTrack.mockResolvedValue(camPub);
+        mockUnpublishTrack.mockResolvedValue(undefined);
+
+        const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+        await simulateConnection(0);
+        await manager.publishCameraStream?.(camStream);
+        await manager.disconnect();
+
+        // ACT:
+        const manager2 = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+        await simulateConnection(1);
+        await manager2.publishCameraStream?.(camStream);
+
+        // ASSERT:
+        expect(mockPublishTrack).toHaveBeenCalledTimes(2);
+    });
+
+    it('should null out publication refs on unexpected disconnect via connection state handler', async () => {
+        // ARRANGE:
+        const micStream = createMockStream();
+        const micPub = createMockPublication();
+        const camStream = createMockCameraStream();
+        const camPub = createMockCameraPublication();
+        mockPublishTrack.mockResolvedValueOnce(micPub).mockResolvedValueOnce(camPub);
+        mockUnpublishTrack.mockResolvedValue(undefined);
+
+        const manager = await createLiveKitStreamingManager(agentId, sessionOptions, options);
+        await simulateConnection();
+        await manager.publishMicrophoneStream?.(micStream);
+        await manager.publishCameraStream?.(camStream);
+        mockUnpublishTrack.mockClear();
+
+        // ACT:
+        const handler = getConnectionStateHandler();
+        handler('disconnected');
+
+        // After unexpected disconnect, calling disconnect again should NOT
+        // try to unpublish (publications were already nulled)
+        await manager.disconnect();
+
+        // ASSERT:
+        expect(mockUnpublishTrack).not.toHaveBeenCalled();
+    });
+});
diff --git a/src/services/streaming-manager/livekit-manager.ts b/src/services/streaming-manager/livekit-manager.ts
index f082e323..3de5e23a 100644
--- a/src/services/streaming-manager/livekit-manager.ts
+++ b/src/services/streaming-manager/livekit-manager.ts
@@ -37,6 +37,11 @@ import { VideoRTCStatsReport } from './stats/report';
 
 const TRACK_SUBSCRIPTION_TIMEOUT_MS = 20000;
 
+interface TrackPublishState {
+    isPublishing: boolean;
+    publication: LocalTrackPublication | null;
+}
+
 async function importLiveKit(): Promise<{
     Room: typeof Room;
     RoomEvent: typeof RoomEvent;
@@ -100,7 +105,8 @@ export async function createLiveKitStreamingManager<T extends CreateSessionV2Opt
     let isConnected = false;
     const streamType = StreamType.Fluent;
     let sharedMediaStream: MediaStream | null = null;
-    let microphonePublication: LocalTrackPublication | null = null;
+    const microphoneState: TrackPublishState = { isPublishing: false, publication: null };
+    const cameraState: TrackPublishState = { isPublishing: false, publication: null };
     let videoStatsMonitor: ReturnType<typeof createVideoStatsMonitor> | null = null;
     let videoStreamingState: StreamingState | null = null;
     // We defer Connected until video track is subscribed to align with WebRTC behavior
@@ -201,6 +207,8 @@ export async function createLiveKitStreamingManager<T extends CreateSessionV2Opt
                 log('LiveKit room disconnected');
                 isConnected = false;
                 hasEmittedConnected = false;
+                microphoneState.publication = null;
+                cameraState.publication = null;
                 callbacks.onConnectionStateChange?.(ConnectionState.Disconnected, 'livekit:disconnected');
                 break;
             case LiveKitConnectionState.Reconnecting:
@@ -395,97 +403,126 @@ export async function createLiveKitStreamingManager<T extends CreateSessionV2Opt
         log('Track subscription failed:', { trackSid, participant, reason });
     }
 
-    function findPublishedMicrophoneTrack(audioTrack: MediaStreamTrack): LocalTrackPublication | null {
-        if (!room) return null;
-
-        const publishedTracks = room.localParticipant.audioTrackPublications;
-
-        if (publishedTracks) {
-            for (const [_, publication] of publishedTracks) {
-                if (publication.source === Track.Source.Microphone && publication.track) {
-                    const publishedTrack = publication.track;
-                    const publishedMediaTrack = publishedTrack.mediaStreamTrack;
-                    if (
-                        publishedMediaTrack === audioTrack ||
-                        (publishedMediaTrack && publishedMediaTrack.id === audioTrack.id)
-                    ) {
-                        return publication as LocalTrackPublication;
-                    }
+    function findPublishedTrack(
+        track: MediaStreamTrack,
+        source: Track.Source,
+        publications: Map<string, LocalTrackPublication>
+    ): LocalTrackPublication | null {
+        for (const [_, publication] of publications) {
+            if (publication.source === source && publication.track) {
+                const publishedMediaTrack = publication.track.mediaStreamTrack;
+                if (publishedMediaTrack === track || publishedMediaTrack?.id === track.id) {
+                    return publication as LocalTrackPublication;
                 }
             }
         }
-
         return null;
     }
 
-    function hasDifferentMicrophoneTrackPublished(audioTrack: MediaStreamTrack): boolean {
-        if (!microphonePublication || !microphonePublication.track) {
-            return false;
-        }
-
-        const publishedMediaTrack = microphonePublication.track.mediaStreamTrack;
-        return publishedMediaTrack !== audioTrack && publishedMediaTrack?.id !== audioTrack.id;
-    }
-
-    async function publishMicrophoneStream(stream: MediaStream): Promise<void> {
+    async function publishTrackStream(
+        state: TrackPublishState,
+        stream: MediaStream,
+        getTracks: (stream: MediaStream) => MediaStreamTrack[],
+        source: Track.Source,
+        getPublications: () => Map<string, LocalTrackPublication>,
+        unpublishFn: () => Promise<void>
+    ): Promise<void> {
         if (!isConnected || !room) {
-            log('Room is not connected, cannot publish microphone stream');
+            log(`Room is not connected, cannot publish ${source} stream`);
             throw new Error('Room is not connected');
         }
 
-        const audioTracks = stream.getAudioTracks();
-        if (audioTracks.length === 0) {
-            log('No audio track found in the provided MediaStream');
+        if (state.isPublishing) {
+            log(`${source} publish already in progress, skipping`);
             return;
         }
 
-        const audioTrack = audioTracks[0];
+        const tracks = getTracks(stream);
+        if (tracks.length === 0) {
+            throw new Error(`No ${source} track found in the provided MediaStream`);
+        }
+
+        const track = tracks[0];
 
-        const existingPublication = findPublishedMicrophoneTrack(audioTrack);
+        const existingPublication = findPublishedTrack(track, source, getPublications());
         if (existingPublication) {
-            log('Microphone track is already published, skipping', {
-                trackId: audioTrack.id,
+            log(`${source} track is already published, skipping`, {
+                trackId: track.id,
                 publishedTrackId: existingPublication.track?.mediaStreamTrack?.id,
             });
-            microphonePublication = existingPublication;
+            state.publication = existingPublication;
             return;
         }
 
-        if (hasDifferentMicrophoneTrackPublished(audioTrack)) {
-            log('Unpublishing existing microphone track before publishing new one');
-            await unpublishMicrophoneStream();
+        if (state.publication?.track) {
+            const publishedMediaTrack = state.publication.track.mediaStreamTrack;
+            if (publishedMediaTrack !== track && publishedMediaTrack?.id !== track.id) {
+                log(`Unpublishing existing ${source} track before publishing new one`);
+                await unpublishFn();
+            }
         }
 
-        log('Publishing microphone track from provided MediaStream', { trackId: audioTrack.id });
+        log(`Publishing ${source} track from provided MediaStream`, { trackId: track.id });
 
+        state.isPublishing = true;
         try {
-            microphonePublication = await room.localParticipant.publishTrack(audioTrack, {
-                source: Track.Source.Microphone,
-            });
-            log('Microphone track published successfully', { trackSid: microphonePublication.trackSid });
+            state.publication = await room.localParticipant.publishTrack(track, { source });
+            log(`${source} track published successfully`, { trackSid: state.publication.trackSid });
         } catch (error) {
-            log('Failed to publish microphone track:', error);
+            log(`Failed to publish ${source} track:`, error);
             throw error;
+        } finally {
+            state.isPublishing = false;
         }
     }
 
-    async function unpublishMicrophoneStream(): Promise<void> {
-        if (!microphonePublication || !microphonePublication.track) {
+    async function unpublishTrackStream(state: TrackPublishState, label: string): Promise<void> {
+        if (!state.publication || !state.publication.track) {
             return;
         }
 
         try {
             if (room) {
-                await room.localParticipant.unpublishTrack(microphonePublication.track);
-                log('Microphone track unpublished');
+                await room.localParticipant.unpublishTrack(state.publication.track, false);
+                log(`${label} track unpublished`);
             }
         } catch (error) {
-            log('Error unpublishing microphone track:', error);
+            log(`Error unpublishing ${label} track:`, error);
         } finally {
-            microphonePublication = null;
+            state.publication = null;
         }
     }
 
+    async function publishMicrophoneStream(stream: MediaStream): Promise<void> {
+        return publishTrackStream(
+            microphoneState,
+            stream,
+            s => s.getAudioTracks(),
+            Track.Source.Microphone,
+            () => room!.localParticipant.audioTrackPublications,
+            unpublishMicrophoneStream
+        );
+    }
+
+    async function unpublishMicrophoneStream(): Promise<void> {
+        return unpublishTrackStream(microphoneState, 'Microphone');
+    }
+
+    async function publishCameraStream(stream: MediaStream): Promise<void> {
+        return publishTrackStream(
+            cameraState,
+            stream,
+            s => s.getVideoTracks(),
+            Track.Source.Camera,
+            () => room!.localParticipant.videoTrackPublications,
+            unpublishCameraStream
+        );
+    }
+
+    async function unpublishCameraStream(): Promise<void> {
+        return unpublishTrackStream(cameraState, 'Camera');
+    }
+
     function cleanMediaStream(): void {
         if (sharedMediaStream) {
             sharedMediaStream.getTracks().forEach(track => track.stop());
@@ -533,8 +570,8 @@ export async function createLiveKitStreamingManager<T extends CreateSessionV2Opt
         }
 
         if (room) {
-            await unpublishMicrophoneStream();
             callbacks.onConnectionStateChange?.(ConnectionState.Disconnecting, reason);
+            await Promise.all([unpublishMicrophoneStream(), unpublishCameraStream()]);
             await room.disconnect();
         }
         cleanMediaStream();
@@ -610,6 +647,8 @@ export async function createLiveKitStreamingManager<T extends CreateSessionV2Opt
         sendTextMessage,
         publishMicrophoneStream,
         unpublishMicrophoneStream,
+        publishCameraStream,
+        unpublishCameraStream,
 
         sessionId,
         streamId: sessionId,
diff --git a/src/types/entities/agents/agent.ts b/src/types/entities/agents/agent.ts
index 777a3a77..05617702 100644
--- a/src/types/entities/agents/agent.ts
+++ b/src/types/entities/agents/agent.ts
@@ -32,12 +32,17 @@ export enum AgentStatus {
     Ready = 'ready',
 }
 
+export interface Vision {
+    enabled: boolean;
+}
+
 export interface Agent {
     id: string;
     username?: string;
     presenter: Presenter;
     llm?: LLM;
     knowledge?: Knowledge;
+    vision?: Vision;
     use_case?: string;
     tags?: string[];
     chats?: number;
diff --git a/src/types/entities/agents/manager.ts b/src/types/entities/agents/manager.ts
index 8a5ffd8b..d00916c8 100644
--- a/src/types/entities/agents/manager.ts
+++ b/src/types/entities/agents/manager.ts
@@ -217,6 +217,18 @@ export interface AgentManager {
      * supported only for livekit manager
      */
     unpublishMicrophoneStream?: () => Promise<void>;
+    /**
+     * Publish a camera video stream to the LiveKit room.
+     * Can be called after connection to enable vision.
+     * supported only for livekit manager
+     */
+    publishCameraStream?: (stream: MediaStream) => Promise<void>;
+    /**
+     * Unpublish the currently published camera stream.
+     * Can be called after connection to disable vision.
+     * supported only for livekit manager
+     */
+    unpublishCameraStream?: () => Promise<void>;
     /**
      * Method to send a chat message to existing chat with the agent
      * @param messages